Osmocom Open Build Service

We truncated the diff of some files because they were too big. If you want to see the full diff for every file, click here.

Changes of Revision 3

commit_d5455a058920501f8bf9dc487d2bd3cab54ddd09.txt Added

commit_d6b3b525be468acb14128b8cc0b5025d30b3fcd8.txt Deleted

osmo-s1gw_0.1.1.51.d6b3.dsc -> osmo-s1gw_0.1.1.54.d545.dsc Changed

osmo-s1gw_0.1.1.51.d6b3.tar.xz/.tarball-version -> osmo-s1gw_0.1.1.54.d545.tar.xz/.tarball-version Changed

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/.github Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/.github/FUNDING.yml Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/.github/ISSUE_TEMPLATE.md Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/.github/workflows Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/.github/workflows/erlang.yml Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/.scripts Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/.scripts/cut.sh Added

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+set -e # Abort on first failure, so we don't mess something up
+
+check_path() {
+    if !  -x "$(command -v "$1")" ; then
+        echo >&2 "error: $1 not available on path"
+        if  -n "$2" ; then
+            echo "($2)"
+        fi
+        exit 1
+    fi
+}
+
+check_path git
+check_path sed
+check_path rebar3 "http://www.rebar3.org"
+
+if  -z "$1" ; then
+    # Missing tag name
+    echo "usage: cut <version>" >&2
+    exit 129
+fi
+if  ! -z "$(git status --short)" ; then
+    # Sanity check
+    echo "fatal: dirty repository" >&2
+    exit 128
+fi
+
+VSN="$1"
+
+# Update version
+sed -i "" -e "s/{vsn, .*}/{vsn, \"$VSN\"}/g" src/*.app.src
+git add src/*.app.src
+if  -f doc/overview.edoc ; then
+    sed -i "" -e "s/@version .*/@version $VSN/g" doc/overview.edoc
+    git add doc/overview.edoc
+fi
+
+# Commit, tag and push
+git commit -m "Version $VSN"
+git tag -s "$VSN" -m "Version $VSN"
+git push && git push --tags
+
+# Clean and publish package and docs
+rm -rf ebin
+rm -rf src/**/*.beam
+rm -rf test/**/*.beam
+rebar3 hex publish

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/.travis.yml Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/CHANGELOG.md Added

@@ -0,0 +1,361 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+
+The format is based on Keep a Changelog, and this project adheres to
+Semantic Versioning.
+
+## Unreleased
+
+## 0.9.2 - 2021-03-06
+
+### Fixed
+
+- Fix a Dialyzer warning on OTP 24 \#223(https://github.com/eproxus/meck/pull/223)
+
+## 0.9.1 - 2021-02-17
+
+### Fixed
+
+- Module references in type specs were not included when renaming modules \#206(https://github.com/eproxus/meck/issues/206)
+- The passthrough clause was not always the last clause in an expect with multiple clauses \#216(https://github.com/eproxus/meck/pull/216)
+
+## 0.9.0 - 2020-06-25
+
+### Added
+
+- Support Erlang 23.0 8c16751(https://github.com/eproxus/meck/commit/8c16751613c7e4ed594e0675004b1c8f68ea8ddd)
+- Add a new function `mocked/0` that returns which modules are currently mocked \#210(https://github.com/eproxus/meck/pull/210)
+
+### Changed
+
+- Validate the options being passed to meck:new \#204(https://github.com/eproxus/meck/pull/204)
+
+### Fixed
+
+- Do not attempt to generate dependencies when mocking 9b3ce75(https://github.com/eproxus/meck/commit/9b3ce754bd69e84127f82d482b8b23b22f7bf866)
+- Add compiler application to dependencies \#209(https://github.com/eproxus/meck/pull/209)
+- meck:ret_spec() opaqueness violates documented usage patterns \#212(https://github.com/eproxus/meck/issues/212)
+
+## 0.8.13 - 2019-01-08
+
+### Removed
+
+- Remove compatibility for Erlang R15 and R16 \#198(https://github.com/eproxus/meck/issues/198)
+
+### Fixed
+
+- Crash when mocking Elixir 1.8-rc.0 compiled module \#201(https://github.com/eproxus/meck/issues/201)
+- Exclude from\_core option from compile\_info when compiling \#202(https://github.com/eproxus/meck/pull/202) (josevalim(https://github.com/josevalim))
+- Isolate backup \*.coverdata from other beam instances \#200(https://github.com/eproxus/meck/pull/200) (dcsommer(https://github.com/dcsommer))
+
+
+## 0.8.12 - 2018-08-08
+
+### Fixed
+
+- History item is not kept while module compiler is running \#194(https://github.com/eproxus/meck/issues/194)
+
+## 0.8.11 - 2018-07-12
+
+### Fixed
+
+- OTP 21 compatibility when using stack traces \#193(https://github.com/eproxus/meck/pull/193) (massemanet(https://github.com/massemanet))
+
+## 0.8.10 - 2018-06-26
+
+### Added
+
+- Support Erlang/OTP 21.0 \#190(https://github.com/eproxus/meck/pull/190) (michalwski(https://github.com/michalwski))
+- Add meck:expects/1,2 \#187(https://github.com/eproxus/meck/pull/187) (elbrujohalcon(https://github.com/elbrujohalcon))
+
+## 0.8.9 - 2017-11-27
+
+### Changed
+
+- Migrate to Rebar 3 and rebar3\_hex \#155(https://github.com/eproxus/meck/issues/155)
+
+### Fixed
+
+- Support running meck with modules built with '+deterministic' compile… \#185(https://github.com/eproxus/meck/pull/185) (nablaa(https://github.com/nablaa))
+- How do I run coverage results after using meck? \#181(https://github.com/eproxus/meck/issues/181)
+- Fix for Rebar 2.x.y on secondary arches \#183(https://github.com/eproxus/meck/pull/183) (lemenkov(https://github.com/lemenkov))
+
+## 0.8.8 - 2017-08-29
+
+### Changed
+
+- Always add debug\_info to compile opts for mocks \#180(https://github.com/eproxus/meck/pull/180) (ericentin(https://github.com/ericentin))
+
+### Fixed
+
+- `{:error, {:no\_abstract\_code, ...}}` with Elixir 1.5.0-rc.0 and Erlang 20.0 \#179(https://github.com/eproxus/meck/issues/179)
+
+
+## 0.8.7 - 2017-06-29
+
+### Fixed
+
+- Remove dialyzer attributes when creating mock $Erlang 20.0$ \#178(https://github.com/eproxus/meck/issues/178)
+
+## 0.8.6 - 2017-06-28
+
+### Fixed
+
+- Remove dialyzer attributes when creating mock 3b772d0(https://github.com/eproxus/meck/commit/3b772d0afc7dd3e7fcae4f256f7728e9975fb412)
+
+## 0.8.5 - 2017-06-28
+
+### Added
+
+- Support Erlang 20 \#175(https://github.com/eproxus/meck/issues/175)
+- Support Erlang 19 \#168(https://github.com/eproxus/meck/pull/168) (WramblinWreck(https://github.com/WramblinWreck))
+- Add meck:get\_state/0, meck:reset\_state/0 \#125(https://github.com/eproxus/meck/issues/125)
+- Add `meck:result/4-5` that returns the result value of a particular function \#163(https://github.com/eproxus/meck/pull/163) (amutake(https://github.com/amutake))
+
+### Deprecated
+
+- Deprecate history and provide history digging functions instead  \#85(https://github.com/eproxus/meck/issues/85)
+- fix \#88 \#162(https://github.com/eproxus/meck/pull/162) (yutopp(https://github.com/yutopp))
+
+### Fixed
+
+- Mocked module will return empty function clause error \#167(https://github.com/eproxus/meck/issues/167)
+- Deleting an expectation in passthrough mode does not restore original function \#88(https://github.com/eproxus/meck/issues/88)
+- Passthrough crashes without +debug\_info \#14(https://github.com/eproxus/meck/issues/14)
+- fix behavio$u$r attributes validation on Erlang R20 \#176(https://github.com/eproxus/meck/pull/176) (RoadRunnr(https://github.com/RoadRunnr))
+- Fix errors in capture/5, capture/6 documentation \#172(https://github.com/eproxus/meck/pull/172) (marco-m(https://github.com/marco-m))
+- Fix eunit compile failure on Erlang 17+ $hamcrest$ \#161(https://github.com/eproxus/meck/pull/161) (marco-m(https://github.com/marco-m))
+
+## 0.8.4 - 2015-12-29
+
+### Added
+
+- Add merge\_expects option to meck\_proc \#153(https://github.com/eproxus/meck/pull/153) (edgurgel(https://github.com/edgurgel))
+
+### Changed
+
+- Update 'problematic modules list' \#156(https://github.com/eproxus/meck/pull/156) (lilrooness(https://github.com/lilrooness))
+- Document the caveat with mocking module-local calls. \#145(https://github.com/eproxus/meck/pull/145) (bpuzon(https://github.com/bpuzon))
+
+### Fixed
+
+- FIX: optional\_callbacks \#151(https://github.com/eproxus/meck/pull/151) (soranoba(https://github.com/soranoba))
+- Fix race condition between meck:unload/1 and calls to the mocked module \#150(https://github.com/eproxus/meck/pull/150) (dszoboszlay(https://github.com/dszoboszlay))
+
+## 0.8.3 - 2015-06-09
+
+### Added
+
+- Support Erlang 18.0 \#139(https://github.com/eproxus/meck/pull/139) (gomoripeti(https://github.com/gomoripeti))
+- Allow hiding 'on\_load' attribute. \#131(https://github.com/eproxus/meck/pull/131) (rlipscombe(https://github.com/rlipscombe))
+
+### Changed
+
+- Removed test and doc from target all in Makefile \#126(https://github.com/eproxus/meck/pull/126) (jfacorro(https://github.com/jfacorro))
+- Fix typo \#143(https://github.com/eproxus/meck/pull/143) (derek121(https://github.com/derek121))
+- Run tests in travis \#138(https://github.com/eproxus/meck/pull/138) (gomoripeti(https://github.com/gomoripeti))
+
+### Fixed
+
+- Please document that modules can be not meck'able \#135(https://github.com/eproxus/meck/issues/135)
+- crypto module \#59(https://github.com/eproxus/meck/issues/59)
+- Fix variable exported from case \#128(https://github.com/eproxus/meck/pull/128) (hazardfn(https://github.com/hazardfn))
+
+
+## 0.8.2 - 2014-05-05
+
+### Added
+
+- Suport Erlang 17.0 and Erlang R16B03-1 \#118(https://github.com/eproxus/meck/pull/118) (myers(https://github.com/myers))
+
+  Add Erlang 17.0 to the test matrix \#122(https://github.com/eproxus/meck/pull/122) (myers(https://github.com/myers))
+- Implicit new \#80(https://github.com/eproxus/meck/issues/80)
+- Should return compilation errors \#33(https://github.com/eproxus/meck/issues/33)
+- Better documentation \#79(https://github.com/eproxus/meck/issues/79)
+
+### Changed
+
+- Put non-strict option in the README.md \#117(https://github.com/eproxus/meck/issues/117)
+- Split tests into several test suites \#83(https://github.com/eproxus/meck/issues/83)
+
+### Fixed
+
+- With a bogus test instantiator, meck fails with {error, enoent} in meck\_cover:read\_cover\_file/1 \#114(https://github.com/eproxus/meck/issues/114)
+- Unable to mock lists module \#87(https://github.com/eproxus/meck/issues/87)
+- Do not consider a 3-tuple return value as an exception \#113(https://github.com/eproxus/meck/pull/113) (lucafavatella(https://github.com/lucafavatella))
+
+
+## 0.8.1 - 2013-08-29
+
+### Fixed
+
+- Attribute errors \#110(https://github.com/eproxus/meck/pull/110) (twonds(https://github.com/twonds))
+
+## 0.8 - 2013-08-17
+
+### Added
+
+- Support R16B \#100(https://github.com/eproxus/meck/pull/100) (rufrozen(https://github.com/rufrozen))

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/CODE_OF_CONDUCT.md Added

@@ -0,0 +1,74 @@
+# Meck Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at meck at alind dot io. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the Contributor Covenanthomepage, version 1.4,
+available at http://contributor-covenant.org/version/1/4version
+
+homepage: http://contributor-covenant.org
+version: http://contributor-covenant.org/version/1/4/

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/CONTRIBUTING.md Added

@@ -0,0 +1,96 @@
+# Contributing to Meck
+
+:+1::tada: First off, thanks for taking the time to contribute! :tada::+1:
+
+The following is a set of guidelines for contributing to Meck. These are just
+guidelines, not rules, use your best judgment and feel free to propose changes
+to this document in a pull request.
+
+## What should I know before I get started?
+
+### Code of Conduct
+
+This project adheres to the Contributor Covenant
+code of conduct(CODE_OF_CONDUCT.md). By participating, you are expected to
+uphold this code. Please report unacceptable behavior to
+meck at alind dot io.
+
+## How Can I Contribute?
+
+You can:
+
+* Submit an issue (see Reporting Bugs(#reporting-bugs))
+* Suggest an enhancement (see Suggesting Enhancements(#suggesting-enhancements))
+* Submit a pull request (see Pull Requests(#pull-requests))
+
+### Your First Contribution
+
+If you want to contribute with documentation, wiki pages, examples, code or
+tests and are unsure of how to start, just open an issue to start a discussion.
+It could be a proposal, a question for support or further direction or any
+other feedback you might have.
+
+### Reporting Bugs
+
+Submitting a good bug report will help identifying, debugging and solving an
+issue.
+
+Please check first if any similar issues have already been reported. If so,
+add to the discussion by commenting on one of those instead.
+
+When you're ready to submit a bug report you can use the
+bug report template(.github/ISSUE_TEMPLATE.md) defined in the project (it's
+automatically used whenever you create a new issue on GitHub). Make sure to
+fill in which versions you are using and instructions of how to reproduce the
+problem.
+
+### Suggesting Enhancements
+
+Suggesting enhancements doesn't have to be as structured as a bug report, but
+should still contain the motivation for the enhancement, an example use case
+and some reasoning why this enhancement should go into Meck itself (reasons it
+should not might include that it works as an external library, that it is more
+test framework related than mocking related etc.)
+
+### Pull Requests
+
+Pull requests really appreciated. To increase the chance of getting your code
+merged, make sure the pull request is small and well structured. You should
+prepare your pull request to try to meet the following guidelines where it
+makes sense:
+
+1. Squash all changes into one commit. If you have many independent changes,
+   submit each in its own pull request.
+2. Document any external API functions changed or added via EDoc.
+3. Run the existing tests to make sure you didn't break anything.
+3. Add working tests that illustrate and cover the changes, or detects an issue
+   to be fixed. A good example is to create a failing test case that exposes
+   the issue you are trying to fix, before fixing it.
+4. Make sure the code and commit follow the style guides(#styleguides).
+5. (Optional) Add type specifications and run Dialyzer where it makes sense.
+
+## Styleguides
+
+### Commit Messages
+
+Commit messages should be limited to 50 characters without a period on the
+subject line and be written in imperative mood.
+
+Longer explanations should be in the body, two lines below the message, wrapped
+at 72 characters.
+
+See How to Write a Git Commit Message(http://chris.beams.io/posts/git-commit/).
+
+### Code
+
+* Lines should be no longer than 80 characters. This is isn't some arbitrary
+  length based on nostalgia, it's just a choice of fitting limit if you want to
+  have several files open at once next to each other on a modern wide screen
+  monitor.
+* Functions should be exported one by one in their own export statement. This
+  is so that one export can easily be rearranged or removed without messing
+  with commas and Erlang attributes.
+
+If you are unsure, try to find some similar code already in the repository and
+mimic that. Otherwise just submit the pull request to get some stylistic
+feedback if necessary.

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/LICENSE Added

@@ -0,0 +1,178 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/NOTICE Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/README.md Added

@@ -0,0 +1,307 @@
+!GitHub Actionsactions badgeactions
+!Hex.pm Versionhex version badgehex
+!Hex.pm Licensehex license badgehex
+!Erlang Versionserlang versions badgeerlang versions
+!Build Toolbuild toolhex
+!Donationsliberapay badgeliberapay
+
+# Meck
+
+A mocking library for Erlang.
+
+  * Features(#features)
+  * Examples(#examples)
+  * Use(#use)
+  * Manual Build(#manual-build)
+  * Caveats(#caveats)
+  * Contribute(#contribute)
+
+## Features
+
+See what's new in 0.8 Release Notesrelease_notes_0.8.
+
+  * Dynamic return values using sequences and loops of static values
+  * Compact definition of mock arguments, clauses and return values
+  * Pass through: call functions in the original module
+  * Complete call history showing calls, return values and exceptions
+  * Mock validation, will invalidate mocks that were not called correctly
+  * Throwing of expected exceptions that keeps the module valid
+  * Throws an error when mocking a module that doesn't exist or has been
+    renamed (disable with option `non_strict`)
+  * Support for Hamcresthamcrest matchers
+  * Automatic backup and restore of cover data
+  * Mock is linked to the creating process and will unload automatically
+    when a crash occurs (disable with option `no_link`)
+  * Mocking of sticky modules (using the option `unstick`)
+
+## Examples
+
+Here's an example of using Meck in the Erlang shell:
+
+```erlang
+Eshell V5.8.4  (abort with ^G)
+1> meck:new(dog, non_strict). % non_strict is used to create modules that don't exist
+ok
+2> meck:expect(dog, bark, fun() -> "Woof!" end).
+ok
+3> dog:bark().
+"Woof!"
+4> meck:validate(dog).
+true
+5> meck:unload(dog).
+ok
+6> dog:bark().
+** exception error: undefined function dog:bark/0
+```
+
+Exceptions can be anticipated by Meck (resulting in validation still passing).
+This is intended to be used to test code that can and should handle certain
+exceptions indeed does take care of them:
+
+```erlang
+5> meck:expect(dog, meow, fun() -> meck:exception(error, not_a_cat) end).
+ok
+6> catch dog:meow().
+{'EXIT',{not_a_cat,{meck,exception,2},
+                    {meck,exec,4},
+                    {dog,meow,},
+                    {erl_eval,do_apply,5},
+                    {erl_eval,expr,5},
+                    {shell,exprs,6},
+                    {shell,eval_exprs,6},
+                    {shell,eval_loop,3}}}
+7> meck:validate(dog).
+true
+```
+
+Normal Erlang exceptions result in a failed validation. The following example is
+just to demonstrate the behavior, in real test code the exception would normally
+come from the code under test (which should, if not expected, invalidate the
+mocked module):
+
+```erlang
+8> meck:expect(dog, jump, fun(Height) when Height > 3 ->
+                                  erlang:error(too_high);
+                             (Height) ->
+                                  ok
+                          end).
+ok
+9> dog:jump(2).
+ok
+10> catch dog:jump(5).
+{'EXIT',{too_high,{meck,exec,4},
+                   {dog,jump,5},
+                   {erl_eval,do_apply,5},
+                   {erl_eval,expr,5},
+                   {shell,exprs,6},
+                   {shell,eval_exprs,6},
+                   {shell,eval_loop,3}}}
+11> meck:validate(dog).
+false
+```
+
+Here's an example of using Meck inside an EUnit test case:
+
+```erlang
+my_test() ->
+    meck:new(my_library_module),
+    meck:expect(my_library_module, fib, fun(8) -> 21 end),
+    ?assertEqual(21, code_under_test:run(fib, 8)), % Uses my_library_module
+    ?assert(meck:validate(my_library_module)),
+    meck:unload(my_library_module).
+```
+
+Pass-through is used when the original functionality of a module should be kept.
+When the option `passthrough` is used when calling `new/2` all functions in the
+original module will be kept in the mock. These can later be overridden by
+calling `expect/3` or `expect/4`.
+
+```erlang
+Eshell V5.8.4  (abort with ^G)
+1> meck:new(string, unstick, passthrough).
+ok
+2> string:strip("  test  ").
+"test"
+```
+
+It's also possible to pass calls to the original function allowing us to
+override only a certain behavior of a function (this usage is compatible with
+the `passthrough` option). `passthrough/1` will always call the original
+function with the same name as the expect is defined in):
+
+```erlang
+Eshell V5.8.4  (abort with ^G)
+1> meck:new(string, unstick, passthrough).
+ok
+2> meck:expect(string, strip, fun
+    ("foo") -> "bar";
+    (String) -> meck:passthrough(String)
+end).
+ok
+3> string:strip("  test  ").
+"test"
+4> string:strip("foo").
+"bar"
+5> meck:unload(string).
+ok
+5> string:strip("foo").
+"foo"
+```
+
+## Use
+
+Meck is best used via Rebar 3rebar_3. Add Meck to the test dependencies
+in your `rebar.config`:
+
+```erlang
+{profiles, {test, {deps, meck}}}.
+```
+
+### Manual Build
+
+Meck uses Rebar 3rebar_3. To build Meck go to the Meck directory
+and simply type:
+
+```sh
+rebar3 compile
+```
+
+In order to run all tests for Meck type the following command from the same
+directory:
+
+```sh
+rebar3 eunit
+```
+
+Documentation can be generated through the use of the following command:
+
+```sh
+rebar3 edoc
+```
+
+### Test Output
+
+Normally the test output is hidden, but if EUnit is run
+directly, two things might seem alarming when running the tests:
+
+  1. Warnings emitted by cover
+  2. An exception printed by SASL
+
+Both are expected due to the way Erlang currently prints errors. The important
+line you should look for is `All XX tests passed`, if that appears all is
+correct.
+
+Caveats
+-------
+
+Meck will have trouble mocking certain modules since Meck works by recompiling
+and reloading modules. Since Erlang have a flat module namespace, replacing a
+module has to be done globally in the Erlang VM. This means certain modules

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/dialyzer.ignore-warnings Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/doc Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/doc/overview.edoc Added

@@ -0,0 +1,25 @@
+%%==============================================================================
+%% Copyright 2010-2017 Adam Lindberg, 2010-2011 Erlang Solutions Ltd
+%%
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%% http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%==============================================================================
+
+@author Adam Lindberg <eproxus@gmail.com>
+@copyright 2010-2017 Adam Lindberg, 2010-2011 Erlang Solutions Ltd
+@version 0.9.2
+@title meck, a Mocking Library for Erlang
+
+@doc
+
+== About ==
+meck is a mocking library for Erlang.

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/rebar.config Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/rebar.lock Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/src Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/src/meck.app.src Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/src/meck.erl Added

@@ -0,0 +1,764 @@
+%%%============================================================================
+%%% Copyright 2010-2017 Adam Lindberg, 2010-2011 Erlang Solutions Ltd
+%%%
+%%% Licensed under the Apache License, Version 2.0 (the "License");
+%%% you may not use this file except in compliance with the License.
+%%% You may obtain a copy of the License at
+%%%
+%%% http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%% Unless required by applicable law or agreed to in writing, software
+%%% distributed under the License is distributed on an "AS IS" BASIS,
+%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%% See the License for the specific language governing permissions and
+%%% limitations under the License.
+%%%============================================================================
+
+%%% @author Adam Lindberg <eproxus@gmail.com>
+%%% @copyright 2010-2017 Adam Lindberg, 2010-2011 Erlang Solutions Ltd
+%%% @doc Module mocking library for Erlang.
+
+-module(meck).
+
+%% API
+-export_type(matcher/0).
+-export_type(args_spec/0).
+-export_type(ret_spec/0).
+-export_type(func_clause_spec/0).
+
+%% Interface exports
+-export(new/1).
+-export(new/2).
+-export(expect/3).
+-export(expect/4).
+-export(sequence/4).
+-export(loop/4).
+-export(delete/3).
+-export(delete/4).
+-export(expects/1).
+-export(expects/2).
+-export(exception/2).
+-export(passthrough/1).
+-export(history/1).
+-export(history/2).
+-export(validate/1).
+-export(unload/0).
+-export(unload/1).
+-export(called/3).
+-export(called/4).
+-export(num_calls/3).
+-export(num_calls/4).
+-export(reset/1).
+-export(capture/5).
+-export(capture/6).
+-export(wait/4).
+-export(wait/5).
+-export(wait/6).
+-export(mocked/0).
+
+%% Syntactic sugar
+-export(loop/1).
+-export(seq/1).
+-export(val/1).
+-export(raise/2).
+-export(passthrough/0).
+-export(exec/1).
+-export(is/1).
+
+%%%============================================================================
+%%% Types
+%%%============================================================================
+
+-type meck_mfa() :: {Mod::atom(), Func::atom(), Args::any()}.
+%% Module, function and arguments that the mock module got called with.
+
+-type stack_trace() :: {Mod::atom(), Func::atom(), AriOrArgs::byte()|any()} |
+                        {Mod::atom(), Func::atom(), AriOrArgs::byte()|any(),
+                         Location::{atom(), any()}}.
+%% Erlang stack trace.
+
+-type history() :: {CallerPid::pid(), meck_mfa(), Result::any()} |
+                    {CallerPid::pid(), meck_mfa(), Class::throw|error|exit,
+                     Reason::any(), stack_trace()}.
+%% Represents a list of either successful function calls with a returned
+%% result or function calls that resulted in an exception with a type,
+%% reason and a stack trace. Each tuple begins with the pid of the process
+%% that made the call to the function.
+
+-opaque matcher() :: meck_matcher:matcher().
+%% Matcher is an entity that is used to check that a particular value meets
+%% some criteria. They are used in defining expectation where Erlang patterns
+%% are not enough. E.g. to check that a numeric value is within bounds.
+%% Instances of `matcher' can be created by {@link is/1} function from either a
+%% predicate function or a hamcrest matcher. (see {@link is/1} for details).
+%% An instance of this type may be specified in any or even all positions of an
+%% {@link arg_spec()}.
+
+-type args_spec() :: any() | '_' | matcher() | non_neg_integer().
+%% Argument specification is used to specify argument patterns throughout Meck.
+%% In particular it is used in definition of expectation clauses by
+%% {@link expect/3}, {@link expect/4}, and by history digging functions
+%% {@link num_called/3}, {@link called/3} to specify what arguments of a
+%% function call of interest should look like.
+%%
+%% An argument specification can be given as a argument pattern list or
+%% as a non-negative integer that represents function clause/call arity.
+%%
+%% If an argument specification is given as an argument pattern, then every
+%% pattern element corresponds to a function argument at the respective
+%% position. '_' is a wildcard that matches any value. In fact you can specify
+%% atom wildcard '_' at any level in the value structure.
+%% (E.g.: {1, blah, {'_', "bar", 2} | '_', 3}). It is also possible to use a
+%% {@link matcher()} created by {@link is/1} in-place of a value pattern.
+%%
+%% If an argument specification is given by an arity, then it is equivalent to
+%% a pattern based argument specification that consists solely of wildcards,
+%% and has the length of arity (e.g.: 3 is equivalent to '_', '_', '_').
+
+-type ret_spec() :: meck_ret_spec:ret_spec().
+%% Opaque data structure that specifies a value or a set of values to be returned
+%% by a mock stub function defined by either {@link expect/3} and {@link expect/4}.
+%% Values of `ret_spec()' are constructed by {@link seq/1}, {@link loop/1},
+%% {@link val/1}, {@link exec/1}, and {@link raise/2} functions. They are used
+%% to specify return values in {@link expect/3} and {@link expect/4} functions,
+%% and also as a parameter of the `stub_all' option of {@link new/2} function.
+%%
+%% Note that any Erlang term `X' is a valid `ret_spec()' equivalent to
+%% `meck:val(X)'.
+
+-type func_clause_spec() :: {args_spec(), ret_spec()}.
+%% It is used in {@link expect/3} and {@link expect/4} to define a function
+%% clause of complex multi-clause expectations.
+
+%%%============================================================================
+%%% Interface exports
+%%%============================================================================
+
+%% @equiv new(Mod, )
+-spec new(Mods) -> ok when
+      Mods :: Mod | Mod,
+      Mod :: atom().
+new(Mod) when is_atom(Mod) -> new(Mod, );
+new(Mod) when is_list(Mod) -> lists:foreach(fun new/1, Mod), ok.
+
+%% @doc Creates new mocked module(s).
+%%
+%% This replaces the current version (if any) of the modules in `Mod'
+%% with an empty module.
+%%
+%% Since this library is intended to use from test code, this
+%% function links a process for each mock to the calling process.
+%%
+%% The valid options are:
+%% <dl>
+%%   <dt>`passthrough'</dt>
+%%   <dd>Retains the original functions, if not mocked by meck. If used along
+%%       with `stub_all' then `stub_all' is ignored.</dd>
+%%
+%%   <dt>`no_link'</dt>
+%%   <dd>Does not link the meck process to the caller process (needed for using
+%%       meck in rpc calls).</dd>
+%%
+%%   <dt>`unstick'</dt>
+%%   <dd>Unstick the module to be mocked (e.g. needed for using meck with
+%%       kernel and stdlib modules).</dd>
+%%
+%%   <dt>`no_passthrough_cover'</dt>
+%%   <dd>If cover is enabled on the module to be mocked then meck will continue
+%%       to capture coverage on passthrough calls. This option allows you to
+%%       disable that feature if it causes problems.</dd>
+%%
+%%   <dt>`{spawn_opt, list()}'</dt>
+%%   <dd>Specify Erlang process spawn options. Typically used to specify
+%%       non-default, garbage collection options.</dd>
+%%
+%%   <dt>`no_history'</dt>
+%%   <dd>Do not store history of meck calls.</dd>
+%%
+%%   <dt>`non_strict'</dt>
+%%   <dd>A mock created with this option will allow setting expectations on
+%%       functions that does not exist in the mocked module. With this
+%%       option on it is even possible to mock non existing modules.</dd>
+%%
+%%   <dt>`{stub_all, '{@link ret_spec()}`}'</dt>
+%%   <dd>Stubs all functions exported from the mocked module. The stubs will
+%%       return whatever defined by {@link ret_spec()} regardless of arguments
+%%       passed in. It is possible to specify this option as just `stub_all'
+%%       then stubs will return atom `ok'. If used along with `passthrough'
+%%       then `stub_all' is ignored. </dd>
+%%
+%%   <dt>`merge_expects'</dt>
+%%   <dd>The expectations for the function/arity signature are merged with
+%%       existing ones instead of replacing all of them each time an
+%%       expectation is added. Expectations are added to the end of the
+%%       function clause list, meaning that pattern matching will be performed
+%%       in the order the expectations were added.</dd>
+%% </dl>
+%%
+%% Possible exceptions:
+%% <dl>

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/src/meck.hrl Added

@@ -0,0 +1,34 @@
+%% Copied from basho/riak_core.
+%%
+%% Fix to make Erlang programs compile on both OTP20 and OTP21.
+%%
+%% Get the stack trace in a way that is backwards compatible. Luckily
+%% OTP_RELEASE was introduced in the same version as the new preferred way of
+%% getting the stack trace. A _catch_/2 macro is provided for consistency in
+%% cases where the stack trace is not needed.
+%%
+%% Example use:
+%%    try f(...)
+%%    catch
+%%         ?_exception_(_, Reason, StackToken) ->
+%%             case Reason of
+%%                 {fail, Error} -> ok;
+%%                 _             -> {'EXIT', Reason, ?_get_stacktrace_(StackToken)}
+%%             end
+%%     end,
+
+-ifdef(OTP_RELEASE). %% This implies 21 or higher
+-define(_exception_(Class, Reason, StackToken), Class:Reason:StackToken).
+-define(_get_stacktrace_(StackToken), StackToken).
+-define(_current_stacktrace_(),
+        try
+            exit('$get_stacktrace')
+        catch
+            exit:'$get_stacktrace':__GetCurrentStackTrace ->
+                __GetCurrentStackTrace
+        end).
+-else.
+-define(_exception_(Class, Reason, _), Class:Reason).
+-define(_get_stacktrace_(_), erlang:get_stacktrace()).
+-define(_current_stacktrace_(), erlang:get_stacktrace()).
+-endif.

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/src/meck_args_matcher.erl Added

@@ -0,0 +1,126 @@
+%%%============================================================================
+%%% Licensed under the Apache License, Version 2.0 (the "License");
+%%% you may not use this file except in compliance with the License.
+%%% You may obtain a copy of the License at
+%%%
+%%% http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%% Unless required by applicable law or agreed to in writing, software
+%%% distributed under the License is distributed on an "AS IS" BASIS,
+%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%% See the License for the specific language governing permissions and
+%%% limitations under the License.
+%%%============================================================================
+
+%%% @private
+-module(meck_args_matcher).
+
+-export_type(args_spec/0).
+-export_type(opt_args_spec/0).
+-export_type(args_matcher/0).
+
+%% API
+-export(new/1).
+-export(arity/1).
+-export(match/2).
+
+%%%============================================================================
+%%% Definitions
+%%%============================================================================
+
+-record(args_matcher, {opt_args_pattern :: opt_args_pattern(),
+                       comp_match_spec :: ets:comp_match_spec(),
+                       has_matchers :: boolean()}).
+
+%%%============================================================================
+%%% Types
+%%%============================================================================
+
+-type opt_args_spec() :: args_spec() | '_'.
+-type args_spec() :: args_pattern() | non_neg_integer().
+-type opt_args_pattern() :: args_pattern() | '_'.
+-type args_pattern() :: any() | '_' | meck_matcher:matcher().
+
+-opaque args_matcher() :: #args_matcher{}.
+
+%%%============================================================================
+%%% API
+%%%============================================================================
+
+-spec new(opt_args_spec()) -> args_matcher().
+new('_') ->
+    MatchSpecItem = meck_util:match_spec_item({'_'}),
+    CompMatchSpec = ets:match_spec_compile(MatchSpecItem),
+    #args_matcher{opt_args_pattern = '_',
+                  comp_match_spec = CompMatchSpec,
+                  has_matchers = false};
+new(Arity) when is_number(Arity) ->
+    ArgsPattern = lists:duplicate(Arity, '_'),
+    MatchSpecItem = meck_util:match_spec_item({ArgsPattern}),
+    CompMatchSpec = ets:match_spec_compile(MatchSpecItem),
+    #args_matcher{opt_args_pattern = ArgsPattern,
+                  comp_match_spec = CompMatchSpec,
+                  has_matchers = false};
+new(ArgsPattern) when is_list(ArgsPattern) ->
+    {HasMatchers, Pattern} = case strip_off_matchers(ArgsPattern) of
+                                 unchanged ->
+                                     {false, ArgsPattern};
+                                 StrippedArgsSpec ->
+                                     {true, StrippedArgsSpec}
+                             end,
+    MatchSpecItem = meck_util:match_spec_item({Pattern}),
+    CompMatchSpec = ets:match_spec_compile(MatchSpecItem),
+    #args_matcher{opt_args_pattern = ArgsPattern,
+                  comp_match_spec = CompMatchSpec,
+                  has_matchers = HasMatchers}.
+
+-spec arity(args_matcher()) -> Arity::non_neg_integer().
+arity(#args_matcher{opt_args_pattern = ArgsPattern}) ->
+    erlang:length(ArgsPattern).
+
+-spec match(Args::any(), args_matcher()) -> boolean().
+match(Args, #args_matcher{opt_args_pattern = OptArgsPattern,
+                          comp_match_spec = CompMatchSpec,
+                          has_matchers = HasMatchers}) ->
+    case ets:match_spec_run({Args}, CompMatchSpec) of
+         ->
+            false;
+        _Matches when HasMatchers andalso erlang:is_list(OptArgsPattern) ->
+            check_by_matchers(Args, OptArgsPattern);
+        _Matches ->
+            true
+    end.
+
+%%%============================================================================
+%%% Internal functions
+%%%============================================================================
+
+-spec strip_off_matchers(args_pattern()) ->
+        NewArgsPattern::args_pattern() | unchanged.
+strip_off_matchers(ArgsPattern) ->
+    strip_off_matchers(ArgsPattern, , false).
+
+-spec strip_off_matchers(args_pattern(), Stripped::any() | '_', boolean()) ->
+        NewArgsPattern::args_pattern() | unchanged.
+strip_off_matchers(ArgPattern | Rest, Stripped, HasMatchers) ->
+    case meck_matcher:is_matcher(ArgPattern) of
+        true ->
+            strip_off_matchers(Rest, '_' | Stripped, true);
+        _ ->
+            strip_off_matchers(Rest, ArgPattern | Stripped, HasMatchers)
+    end;
+strip_off_matchers(, Stripped, true) ->
+    lists:reverse(Stripped);
+strip_off_matchers(, _Stripped, false) ->
+    unchanged.
+
+-spec check_by_matchers(Args ::any(), MaybeMatchers::any()) -> boolean().
+check_by_matchers(Arg | RestArgs, MaybeMatcher | RestMaybeMatchers) ->
+    case meck_matcher:match_ignore(Arg, MaybeMatcher) of
+        true ->
+            check_by_matchers(RestArgs, RestMaybeMatchers);
+        _Else ->
+            false
+    end;
+check_by_matchers(, ) ->
+    true.
\ No newline at end of file

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/src/meck_code.erl Added

@@ -0,0 +1,148 @@
+%%=============================================================================
+%% Copyright 2010-2017 Adam Lindberg, 2010-2011 Erlang Solutions Ltd
+%%
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%% http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%=============================================================================
+
+%% @hidden
+%% @author Adam Lindberg <eproxus@gmail.com>
+%% @copyright 2010-2017 Adam Lindberg, 2010-2011 Erlang Solutions Ltd
+%% @doc Module wrangling helper functions.
+
+-module(meck_code).
+
+%% Interface exports
+-export(abstract_code/1).
+-export(add_exports/2).
+-export(beam_file/1).
+-export(compile_and_load_forms/1).
+-export(compile_and_load_forms/2).
+-export(compile_options/1).
+-export(enable_on_load/2).
+-export(rename_module/3).
+
+%% Types
+-type erlang_form() :: term().
+-type compile_options() :: term().
+-type export() :: {atom(), byte()}.
+
+%%=============================================================================
+%% Interface exports
+%%=============================================================================
+
+-spec abstract_code(binary()) -> erlang_form().
+abstract_code(BeamFile) ->
+    case beam_lib:chunks(BeamFile, abstract_code) of
+        {ok, {_, {abstract_code, {raw_abstract_v1, Forms}}}} ->
+            Forms;
+        {ok, {_, {abstract_code, no_abstract_code}}} ->
+            throw(no_abstract_code)
+    end.
+
+-spec add_exports(export(), erlang_form()) -> erlang_form().
+add_exports(Exports, AbsCode) ->
+    {attribute, Line, export, OrigExports} = lists:keyfind(export, 3, AbsCode),
+    Attr = {attribute, Line, export, OrigExports ++ Exports},
+    lists:keyreplace(export, 3, AbsCode, Attr).
+
+-spec beam_file(module()) -> binary().
+beam_file(Module) ->
+    % code:which/1 cannot be used for cover_compiled modules
+    case code:get_object_code(Module) of
+        {_, Binary, _Filename} -> Binary;
+        error                  -> throw({object_code_not_found, Module})
+    end.
+
+-spec compile_and_load_forms(erlang_form()) -> binary().
+compile_and_load_forms(AbsCode) -> compile_and_load_forms(AbsCode, ).
+
+-spec compile_and_load_forms(erlang_form(), compile_options()) -> binary().
+compile_and_load_forms(AbsCode, Opts) ->
+    case compile:forms(AbsCode, return_errors|Opts) of
+        {ok, ModName, Binary} ->
+            load_binary(ModName, Binary),
+            Binary;
+        {ok, ModName, Binary, _Warnings} ->
+            load_binary(ModName, Binary),
+            Binary;
+        Error ->
+            exit({compile_forms, Error})
+    end.
+
+-spec compile_options(binary() | module()) -> compile_options().
+compile_options(BeamFile) when is_binary(BeamFile) ->
+    case beam_lib:chunks(BeamFile, compile_info) of
+        {ok, {_, {compile_info, Info}}} ->
+          filter_options(proplists:get_value(options, Info));
+        _ ->
+            
+    end;
+compile_options(Module) ->
+  filter_options(proplists:get_value(options, Module:module_info(compile))).
+
+enable_on_load(Forms, false) ->
+    Map = fun({attribute,L,on_load,{F,A}}) -> {attribute,L,export,{F,A}};
+             (Other) -> Other
+          end,
+    lists:map(Map, Forms);
+enable_on_load(Forms, _) ->
+    Forms.
+
+-spec rename_module(erlang_form(), module(), module()) -> erlang_form().
+rename_module(Forms, Old, New) ->
+    lists:map(fun(F) -> rename_module_in_form(F, Old, New) end, Forms).
+
+%%=============================================================================
+%% Internal functions
+%%=============================================================================
+
+load_binary(Name, Binary) ->
+    case code:load_binary(Name, "", Binary) of
+        {module, Name}  -> ok;
+        {error, Reason} -> exit({error_loading_module, Name, Reason})
+    end.
+
+% parse transforms have already been applied to the abstract code in the
+% module, and often are not always available when compiling the forms, so
+% filter them out of the options.
+%
+% Furthermore, since Erlang/OTP 20, a code may be compiled from core but
+% still have abstract code, so we make sure to remove the from_core option
+% as we always compile it as a form.
+%
+% The -MMD option (makedep_side_effect) needs to be removed, otherwise
+% the compiler will attempt to generate a dependency file.
+filter_options (Options) ->
+    case Options of
+        undefined -> ;
+        _ -> lists:filter(
+               fun({parse_transform,_})  -> false;
+                  (makedep_side_effect)  -> false;
+                  (from_core)            -> false;
+                  (_)                    -> true
+               end, Options)
+    end.
+
+rename_module_in_form({attribute, Line, AttrName, AttrData}, Old, New) ->
+    {attribute, Line, AttrName,
+        rename_module_in_attribute(AttrName, AttrData, Old, New)
+    };
+rename_module_in_form(Form, _Old, _New) ->
+    Form.
+
+rename_module_in_attribute(module, Old, Old, New) ->
+    New;
+rename_module_in_attribute(spec, {{Old, Fun, Arity}, Spec}, Old, New) ->
+    {{New, Fun, Arity}, Spec};
+rename_module_in_attribute(_AttrName, AttrData, _Old, _New) ->
+    AttrData.

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/src/meck_code_gen.erl Added

@@ -0,0 +1,225 @@
+%%%============================================================================
+%%% Licensed under the Apache License, Version 2.0 (the "License");
+%%% you may not use this file except in compliance with the License.
+%%% You may obtain a copy of the License at
+%%%
+%%% http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%% Unless required by applicable law or agreed to in writing, software
+%%% distributed under the License is distributed on an "AS IS" BASIS,
+%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%% See the License for the specific language governing permissions and
+%%% limitations under the License.
+%%%============================================================================
+
+%%% @private
+%%% @doc Implements code generation for mocked module and also contains code
+%%% pieces that are called in the generated module context.
+-module(meck_code_gen).
+
+%% API
+-export(to_forms/2).
+-export(get_current_call/0).
+
+%% Exported to be accessible from generated modules.
+-export(exec/4).
+
+-include("meck.hrl").
+
+%%%============================================================================
+%%% Definitions
+%%%============================================================================
+
+-define(CURRENT_CALL, '$meck_call').
+-define(call(Module, Function, Arguments),
+        {call, ?LINE,
+         {remote, ?LINE, ?atom(Module), ?atom(Function)},
+         Arguments}).
+
+-define(atom(Atom), {atom, ?LINE, Atom}).
+-define(integer(Integer), {integer, ?LINE, Integer}).
+-define(var(Name), {var, ?LINE, Name}).
+-define(attribute(Attribute, Args), {attribute, ?LINE, Attribute, Args}).
+-define(function(Name, Arity, Clauses),
+        {function, ?LINE, Name, Arity, Clauses}).
+-define(clause(Arguments, Body), {clause, ?LINE, Arguments, , Body}).
+-define(tuple(Elements), {tuple, ?LINE, Elements}).
+
+%%%============================================================================
+%%% API
+%%%============================================================================
+
+to_forms(Mod, Expects) ->
+    {Exports, Functions} = functions(Mod, Expects),
+    ?attribute(module, Mod) ++ attributes(Mod) ++ Exports ++ Functions.
+
+-spec get_current_call() -> {Mod::atom(), Func::atom()}.
+get_current_call() ->
+    get(?CURRENT_CALL).
+
+%%%============================================================================
+%%% Internal functions
+%%%============================================================================
+
+attribute({Key, _Value}, Attrs)
+    when Key =:= vsn;
+         Key =:= deprecated;
+         Key =:= optional_callbacks;
+     Key =:= dialyzer ->
+    Attrs;
+attribute({Key, Value}, Attrs)
+  when (Key =:= behaviour orelse Key =:= behavior)
+       andalso is_list(Value) ->
+    lists:foldl(fun(Behavior, Acc) -> ?attribute(Key, Behavior) | Acc end,
+                Attrs, Value);
+attribute({Key, Value}, Attrs) ->
+    ?attribute(Key, Value) | Attrs.
+
+attributes(Mod) ->
+    try
+        lists:foldl(fun attribute/2, ,
+                    proplists:get_value(attributes, Mod:module_info(), ))
+    catch
+        error:undef -> 
+    end.
+
+functions(Mod, Expects) ->
+    dict:fold(fun(Export, Expect, {Exports, Functions}) ->
+        {?attribute(export, Export) | Exports,
+         func(Mod, Export, Expect) | Functions}
+              end,
+              {, },
+              Expects).
+
+func(Mod, {Func, Arity}, {anon, Arity, Result}) ->
+    case contains_opaque(Result) of
+        true ->
+            func_exec(Mod, Func, Arity);
+        false ->
+            func_native(Mod, Func, Arity, Result)
+    end;
+func(Mod, {Func, Arity}, _Expect) ->
+    func_exec(Mod, Func, Arity).
+
+func_exec(Mod, Func, Arity) ->
+    Args = args(Arity),
+    ?function(Func, Arity,
+              ?clause(Args,
+                       ?call(?MODULE, exec,
+                              ?call(erlang, self, ),
+                               ?atom(Mod),
+                               ?atom(Func),
+                               list(Args)))).
+
+func_native(Mod, Func, Arity, Result) ->
+    Args = args(Arity),
+    AbsResult = erl_parse:abstract(Result),
+    ?function(
+            Func, Arity,
+            ?clause(
+                    Args,
+                    ?call(gen_server, cast,
+                           ?atom(meck_util:proc_name(Mod)),
+                            ?tuple(?atom(add_history),
+                                    ?tuple(?call(erlang, self, ),
+                                            ?tuple(?atom(Mod), ?atom(Func),
+                                                    list(Args)),
+                                            AbsResult))),
+                     AbsResult)).
+
+contains_opaque(Term) when is_pid(Term); is_port(Term); is_function(Term);
+    is_reference(Term) ->
+    true;
+contains_opaque(Term) when is_list(Term) ->
+    lists_any(fun contains_opaque/1, Term);
+contains_opaque(Term) when is_tuple(Term) ->
+    lists_any(fun contains_opaque/1, tuple_to_list(Term));
+contains_opaque(_Term) ->
+    false.
+
+%% based on lists.erl but accepts improper lists.
+lists_any(Pred, ) when is_function(Pred, 1) -> false;
+lists_any(Pred, Hd|Tail) ->
+    case Pred(Hd) of
+        true -> true;
+        false -> lists_any(Pred, Tail)
+    end;
+lists_any(Pred, Improper) ->
+    Pred(Improper).
+
+args(0)     -> ;
+args(Arity) -> ?var(var_name(N)) || N <- lists:seq(1, Arity).
+
+list()    -> {nil, ?LINE};
+list(H|T) -> {cons, ?LINE, H, list(T)}.
+
+var_name(A) -> list_to_atom("A"++integer_to_list(A)).
+
+%% @hidden
+-spec exec(CallerPid::pid(), Mod::atom(), Func::atom(), Args::any()) ->
+        Result::any().
+exec(Pid, Mod, Func, Args) ->
+    try meck_proc:get_result_spec(Mod, Func, Args) of
+        undefined ->
+            meck_proc:invalidate(Mod),
+            raise(Pid, Mod, Func, Args, error, function_clause, );
+        ResultSpec ->
+            eval(Pid, Mod, Func, Args, ResultSpec)
+    catch
+        error:{not_mocked, Mod} ->
+            apply(Mod, Func, Args)
+    end.
+
+-spec eval(Pid::pid(), Mod::atom(), Func::atom(), Args::any(),
+           ResultSpec::any()) -> Result::any() | no_return().
+eval(Pid, Mod, Func, Args, ResultSpec) ->
+    put(?CURRENT_CALL, {Mod, Func}),
+    try
+        Result = meck_ret_spec:eval_result(Mod, Func, Args, ResultSpec),
+        meck_proc:add_history(Mod, Pid, Func, Args, Result),
+        Result
+    catch
+        ?_exception_(Class, Reason, StackToken) ->
+            handle_exception(Pid, Mod, Func, Args,
+                             Class, Reason, ?_get_stacktrace_(StackToken))
+    after
+        erase(?CURRENT_CALL)
+    end.
+
+-spec handle_exception(CallerPid::pid(), Mod::atom(), Func::atom(),
+                       Args::any(), Class:: exit | error | throw,
+                       Reason::any(),
+                       Stack::meck_history:stack_trace()) ->
+        no_return().
+handle_exception(Pid, Mod, Func, Args, Class, Reason, Stack) ->
+    case meck_ret_spec:is_meck_exception(Reason) of
+        {true, MockedClass, MockedReason} ->
+            raise(Pid, Mod, Func, Args, MockedClass, MockedReason, Stack);
+        _ ->
+            meck_proc:invalidate(Mod),

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/src/meck_cover.erl Added

@@ -0,0 +1,148 @@
+%%=============================================================================
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%% http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%=============================================================================
+
+%% @private
+%% @doc Module containing functions needed by meck to integrate with cover.
+
+-module(meck_cover).
+
+%% Interface exports
+-export(compile_beam/2).
+-export(rename_module/2).
+-export(dump_coverdata/1).
+
+-ignore_xref({cover, compile_beams, 1}).
+-ignore_xref({cover, compile_beam, 2}).
+-ignore_xref({cover, get_term, 1}).
+-ignore_xref({cover, write, 2}).
+
+%%=============================================================================
+%% Interface exports
+%%=============================================================================
+
+%% @doc Enabled cover on `<name>_meck_original'.
+compile_beam(OriginalMod, Bin) ->
+    CompileBeams = alter_cover(),
+    {ok, _} = CompileBeams({OriginalMod, Bin}).
+
+%% @doc Given a cover file `File' exported by `cover:export' overwrite
+%% the module name with `Name'.
+rename_module(File, Name) ->
+    NewTerms = change_cover_mod_name(read_cover_file(File), Name),
+    write_terms(File, NewTerms),
+    ok.
+
+%% @doc Dump cover data for `Mod' into a .coverdata file in the current
+%% directory. Return the absolute path to the backup file.
+dump_coverdata(Mod) ->
+    {ok, CWD} = file:get_cwd(),
+    File = lists:concat(Mod, ".", os:getpid(), ".coverdata"),
+    Path = filename:join(CWD, File),
+    ok = cover:export(Path, Mod),
+    Path.
+
+%%=============================================================================
+%% Internal functions
+%%=============================================================================
+
+%% @private
+%%
+%% @doc Alter the cover BEAM module to export some of it's private
+%% functions.  This is done for two reasons:
+%%
+%% 1. Meck needs to alter the export analysis data on disk and
+%% therefore needs to understand this format.  This is why `get_term'
+%% and `write' are exposed.
+%%
+%% 2. In order to avoid creating temporary files meck needs direct
+%% access to `compile_beam/2' which allows passing a binary.
+%% In OTP 18.0 the internal API of cover changed a bit and
+%% compile_beam/2 was replaced by compile_beams/1.
+-dialyzer({no_missing_calls, alter_cover/0}). % for cover:compile_beams/1
+alter_cover() ->
+    CoverExports = cover:module_info(exports),
+    case {lists:member({compile_beams,1}, CoverExports),
+          lists:member({compile_beam,2}, CoverExports)} of
+        {true, _} ->
+            fun cover:compile_beams/1;
+        {_, true} ->
+            fun compile_beam_wrapper/1;
+        {false, false} ->
+            Beam = meck_code:beam_file(cover),
+            AbsCode = meck_code:abstract_code(Beam),
+            {Exports, CompileBeams} =
+                case lists:member({analyse,0}, CoverExports) of
+                    true ->
+                        %% new API from OTP 18.0 on
+                        {{compile_beams, 1}, {get_term, 1}, {write, 2},
+                         fun cover:compile_beams/1};
+                    false ->
+                        {{compile_beam, 2}, {get_term, 1}, {write, 2},
+                         fun compile_beam_wrapper/1}
+                end,
+            AbsCode2 = meck_code:add_exports(Exports, AbsCode),
+            _Bin = meck_code:compile_and_load_forms(AbsCode2),
+            CompileBeams
+    end.
+
+%% wrap cover's pre-18.0 internal API to simulate the new API
+-dialyzer({no_missing_calls, compile_beam_wrapper/1}). % for cover:compile_beam/2
+compile_beam_wrapper(ModFiles) ->
+    cover:compile_beam(Mod, Bin)||{Mod, Bin} <- ModFiles.
+
+change_cover_mod_name(CoverTerms, Name) ->
+    {_, Terms} = lists:foldl(fun change_name_in_term/2, {Name,}, CoverTerms),
+    Terms.
+
+change_name_in_term({file, Mod, File}, {Name, Terms}) ->
+    Term2 = {file, Name, replace_string(File, Mod, Name)},
+    {Name, Term2|Terms};
+change_name_in_term({Bump={bump,_,_,_,_,_},_}=Term, {Name, Terms}) ->
+    Bump2 = setelement(2, Bump, Name),
+    Term2 = setelement(1, Term, Bump2),
+    {Name, Term2|Terms};
+change_name_in_term({_Mod,Clauses}, {Name, Terms}) ->
+    Clauses2 = lists:foldl(fun change_name_in_clause/2, {Name, }, Clauses),
+    Term2 = {Name, Clauses2},
+    {Name, Term2|Terms}.
+
+change_name_in_clause(Clause, {Name, NewClauses}) ->
+    {Name, setelement(1, Clause, Name)|NewClauses}.
+
+replace_string(File, Old, New) ->
+    Old2 = atom_to_list(Old),
+    New2 = atom_to_list(New),
+    re:replace(File, Old2, New2, {return, list}).
+
+read_cover_file(File) ->
+    {ok, Fd} = file:open(File, read, binary, raw),
+    Terms = get_terms(Fd, ),
+    ok = file:close(Fd),
+    Terms.
+
+-dialyzer({no_missing_calls, get_terms/2}). % for cover:get_term/1
+get_terms(Fd, Terms) ->
+    case cover:get_term(Fd) of
+        eof -> Terms;
+        Term -> get_terms(Fd, Term|Terms)
+    end.
+
+write_terms(File, Terms) ->
+    {ok, Fd} = file:open(File, write, binary, raw),
+    lists:foreach(write_term(Fd), Terms),
+    ok.
+
+-dialyzer({no_missing_calls, write_term/1}). % for cover:write/2
+write_term(Fd) ->
+    fun(Term) -> cover:write(Term, Fd) end.

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/src/meck_expect.erl Added

@@ -0,0 +1,146 @@
+%%%============================================================================
+%%% Licensed under the Apache License, Version 2.0 (the "License");
+%%% you may not use this file except in compliance with the License.
+%%% You may obtain a copy of the License at
+%%%
+%%% http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%% Unless required by applicable law or agreed to in writing, software
+%%% distributed under the License is distributed on an "AS IS" BASIS,
+%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%% See the License for the specific language governing permissions and
+%%% limitations under the License.
+%%%============================================================================
+
+%%% @private
+%%% @doc Provides expectation processing functions.
+-module(meck_expect).
+
+%% API
+-export_type(func_ari/0).
+-export_type(expect/0).
+
+-export(new/2).
+-export(new/3).
+-export(new_passthrough/1).
+-export(new_dummy/2).
+-export(func_ari/1).
+-export(is_passthrough/1).
+-export(fetch_result/2).
+
+%%%============================================================================
+%%% Types
+%%%============================================================================
+
+-type func_clause_spec() :: {meck_args_matcher:args_spec(),
+                             meck_ret_spec:ret_spec()}.
+
+-type func_clause() :: {meck_args_matcher:args_matcher(),
+                        meck_ret_spec:ret_spec()}.
+
+-type func_ari() :: {Func::atom(), Ari::byte()}.
+-type expect() :: {func_ari(), func_clause()}.
+
+%%%============================================================================
+%%% API
+%%%============================================================================
+
+-spec new(Func::atom(), fun() | func_clause_spec()) -> expect().
+new(Func, StubFun) when is_function(StubFun) ->
+    {arity, Arity} = erlang:fun_info(StubFun, arity),
+    Clause = {meck_args_matcher:new(Arity), meck_ret_spec:exec(StubFun)},
+    {{Func, Arity}, Clause};
+new(Func, ClauseSpecs) when is_list(ClauseSpecs) ->
+    {Arity, Clauses} = parse_clause_specs(ClauseSpecs),
+    {{Func, Arity}, Clauses}.
+
+-spec new(Func::atom(),
+          meck_args_matcher:args_spec(),
+          meck_ret_spec:ret_spec()) ->
+        expect().
+new(Func, ArgsSpec, RetSpec) ->
+    {Ari, Clause} = parse_clause_spec({ArgsSpec, RetSpec}),
+    {{Func, Ari}, Clause}.
+
+-spec new_passthrough(func_ari()) -> expect().
+new_passthrough({Func, Ari}) ->
+    {{Func, Ari}, {meck_args_matcher:new(Ari), meck_ret_spec:passthrough()}}.
+
+-spec new_dummy(func_ari(), meck_ret_spec:ret_spec()) -> expect().
+new_dummy({Func, Ari}, RetSpec) ->
+    {{Func, Ari}, {meck_args_matcher:new(Ari), RetSpec}}.
+
+-spec func_ari(expect()) -> func_ari().
+func_ari({FuncAri, _Clauses}) ->
+    FuncAri.
+
+-spec is_passthrough(expect()) -> boolean().
+is_passthrough({_FuncAri, {_Matcher, RetSpec}}) ->
+    meck_ret_spec:is_passthrough(RetSpec);
+is_passthrough(_) ->
+    false.
+
+-spec fetch_result(Args::any(), expect()) ->
+        {undefined, unchanged} |
+        {meck_ret_spec:result_spec(), unchanged} |
+        {meck_ret_spec:result_spec(), NewExpect::expect()}.
+fetch_result(Args, {FuncAri, Clauses}) ->
+    case find_matching_clause(Args, Clauses) of
+        not_found ->
+            {undefined, unchanged};
+        {ArgsMatcher, RetSpec} ->
+            case meck_ret_spec:retrieve_result(RetSpec) of
+                {ResultSpec, unchanged} ->
+                    {ResultSpec, unchanged};
+                {ResultSpec, NewRetSpec} ->
+                    NewClauses = lists:keyreplace(ArgsMatcher, 1, Clauses,
+                                                  {ArgsMatcher, NewRetSpec}),
+                    {ResultSpec, {FuncAri, NewClauses}}
+            end
+    end.
+
+%%%============================================================================
+%%% Internal functions
+%%%============================================================================
+
+-spec parse_clause_specs(func_clause_spec()) -> {Ari::byte(), func_clause()}.
+parse_clause_specs(ClauseSpec | Rest) ->
+    {Ari, Clause} = parse_clause_spec(ClauseSpec),
+    parse_clause_specs(Rest, Ari, Clause).
+
+-spec parse_clause_specs(func_clause_spec(),
+                         FirstClauseAri::byte(),
+                         Clauses::func_clause()) ->
+        {Ari::byte(), func_clause()}.
+parse_clause_specs(ClauseSpec | Rest, FirstClauseAri, Clauses) ->
+    {Ari, Clause} = parse_clause_spec(ClauseSpec),
+    case Ari of
+        FirstClauseAri ->
+            parse_clause_specs(Rest, FirstClauseAri, Clause | Clauses);
+        _ ->
+            erlang:error({invalid_arity, {{expected, FirstClauseAri},
+                                          {actual, Ari},
+                                          {clause, ClauseSpec}}})
+    end;
+parse_clause_specs(, FirstClauseAri, Clauses) ->
+    {FirstClauseAri, lists:reverse(Clauses)}.
+
+-spec parse_clause_spec(func_clause_spec()) ->
+        {Ari::byte(), func_clause()}.
+parse_clause_spec({ArgsSpec, RetSpec}) ->
+    ArgsMatcher = meck_args_matcher:new(ArgsSpec),
+    Ari = meck_args_matcher:arity(ArgsMatcher),
+    Clause = {ArgsMatcher, RetSpec},
+    {Ari, Clause}.
+
+-spec find_matching_clause(Args::any(), Defined::func_clause()) ->
+        Matching::func_clause() | not_found.
+find_matching_clause(Args, {ArgsMatcher, RetSpec} | Rest) ->
+    case meck_args_matcher:match(Args, ArgsMatcher) of
+        true ->
+            {ArgsMatcher, RetSpec};
+        _Else ->
+            find_matching_clause(Args, Rest)
+    end;
+find_matching_clause(_Args, ) ->
+    not_found.

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/src/meck_history.erl Added

@@ -0,0 +1,148 @@
+%%%============================================================================
+%%% Licensed under the Apache License, Version 2.0 (the "License");
+%%% you may not use this file except in compliance with the License.
+%%% You may obtain a copy of the License at
+%%%
+%%% http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%% Unless required by applicable law or agreed to in writing, software
+%%% distributed under the License is distributed on an "AS IS" BASIS,
+%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%% See the License for the specific language governing permissions and
+%%% limitations under the License.
+%%%============================================================================
+
+%%% @private
+%%% @doc Provides functions for digging information from the recorded call
+%%% history.
+-module(meck_history).
+
+%% API
+-export_type(stack_trace_rec_r14b/0).
+-export_type(stack_trace_rec_r15b/0).
+-export_type(stack_trace/0).
+-export_type(meck_mfa/0).
+-export_type(successfull_call/0).
+-export_type(faulty_call/0).
+-export_type(history_record/0).
+-export_type(history/0).
+
+-export(get_history/2).
+-export(num_calls/4).
+-export(capture/6).
+-export(result/5).
+-export(new_filter/3).
+
+%%%============================================================================
+%%% Types
+%%%============================================================================
+
+-type stack_trace_rec_r14b() :: {Mod::atom(), Func::atom(),
+                                 AriOrArgs::byte() | any()}.
+
+-type stack_trace_rec_r15b() :: {Mod::atom(), Func::atom(),
+                                 AriOrArgs::byte() | any(),
+                                 Location::{atom(), any()}}.
+
+-type stack_trace() :: stack_trace_rec_r14b() | stack_trace_rec_r15b().
+
+-type meck_mfa() :: {Mod::atom(), Func::atom(), Args::term()}.
+
+-type successfull_call() :: {CallerPid::pid(), meck_mfa(), Result::any()}.
+
+-type faulty_call() :: {CallerPid::pid(), meck_mfa(), Class::exit|error|throw,
+                        Reason::term(), stack_trace()}.
+
+-type history_record() :: successfull_call() | faulty_call().
+-type history() :: history_record().
+
+-type opt_pid() :: pid() | '_'.
+-type opt_func() :: atom() | '_'.
+
+%%%============================================================================
+%%% API
+%%%============================================================================
+
+-spec get_history(opt_pid(), Mod::atom()) -> history().
+get_history('_', Mod) ->
+    meck_proc:get_history(Mod);
+get_history(CallerPid, Mod) ->
+    ArgsMatcher = meck_args_matcher:new('_'),
+    lists:filter(new_filter(CallerPid, '_', ArgsMatcher),
+                 meck_proc:get_history(Mod)).
+
+-spec num_calls(opt_pid(), Mod::atom(), opt_func(),
+                meck_args_matcher:opt_args_spec()) ->
+        non_neg_integer().
+num_calls(CallerPid, Mod, OptFunc, OptArgsSpec) ->
+    ArgsMatcher = meck_args_matcher:new(OptArgsSpec),
+    Filter = new_filter(CallerPid, OptFunc, ArgsMatcher),
+    Filtered = lists:filter(Filter, meck_proc:get_history(Mod)),
+    length(Filtered).
+
+-spec capture(Occur::pos_integer(), opt_pid(), Mod::atom(), Func::atom(),
+              meck_args_matcher:opt_args_spec(), ArgNum::pos_integer()) ->
+        ArgValue::any().
+capture(Occur, OptCallerPid, Mod, Func, OptArgsSpec, ArgNum) ->
+    ArgsMatcher = meck_args_matcher:new(OptArgsSpec),
+    Filter = new_filter(OptCallerPid, Func, ArgsMatcher),
+    Filtered = lists:filter(Filter, meck_proc:get_history(Mod)),
+    case nth_record(Occur, Filtered) of
+        not_found ->
+            erlang:error(not_found);
+        {_CallerPid, {_Mod, _Func, Args}, _Result} ->
+            lists:nth(ArgNum, Args);
+        {_CallerPid, {_Mod, Func, Args}, _Class, _Reason, _Trace} ->
+            lists:nth(ArgNum, Args)
+    end.
+
+-spec result(Occur::pos_integer(), opt_pid(), Mod::atom(), Func::atom(),
+             meck_args_matcher:opt_args_spec()) -> ResultValue::any().
+result(Occur, OptCallerPid, Mod, Func, OptArgsSpec) ->
+    ArgsMatcher = meck_args_matcher:new(OptArgsSpec),
+    Filter = new_filter(OptCallerPid, Func, ArgsMatcher),
+    Filtered = lists:filter(Filter, meck_proc:get_history(Mod)),
+    case nth_record(Occur, Filtered) of
+        not_found ->
+            erlang:error(not_found);
+        {_CallerPid, _MFA, Result} ->
+            Result;
+        {_CallerPid, _MFA, Class, Reason, Trace} ->
+            erlang:raise(Class, Reason, Trace)
+    end.
+
+-spec new_filter(opt_pid(), opt_func(), meck_args_matcher:args_matcher()) ->
+        fun((history_record()) -> boolean()).
+new_filter(TheCallerPid, TheFunc, ArgsMatcher) ->
+    fun({CallerPid, {_Mod, Func, Args}, _Result})
+          when (TheFunc == '_' orelse Func == TheFunc) andalso
+               (TheCallerPid == '_' orelse CallerPid == TheCallerPid) ->
+            meck_args_matcher:match(Args, ArgsMatcher);
+       ({CallerPid, {_Mod, Func, Args}, _Class, _Reason, _StackTrace})
+          when (TheFunc == '_' orelse Func == TheFunc) andalso
+               (TheCallerPid == '_' orelse CallerPid == TheCallerPid) ->
+            meck_args_matcher:match(Args, ArgsMatcher);
+       (_Other) ->
+            false
+    end.
+
+%%%============================================================================
+%%% Internal functions
+%%%============================================================================
+
+-spec nth_record(Occur::pos_integer(), history()) -> history_record() |
+                                                     not_found.
+nth_record(Occur, History) ->
+    try
+        case Occur of
+            first ->
+                lists:nth(1, History);
+            last ->
+                lists:last(History);
+            _Else ->
+                lists:nth(Occur, History)
+        end
+    catch
+        error:_Reason ->
+            not_found
+    end.

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/src/meck_matcher.erl Added

@@ -0,0 +1,88 @@
+%%%============================================================================
+%%% Licensed under the Apache License, Version 2.0 (the "License");
+%%% you may not use this file except in compliance with the License.
+%%% You may obtain a copy of the License at
+%%%
+%%% http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%% Unless required by applicable law or agreed to in writing, software
+%%% distributed under the License is distributed on an "AS IS" BASIS,
+%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%% See the License for the specific language governing permissions and
+%%% limitations under the License.
+%%%============================================================================
+
+%%% @private
+%%% @doc This module introduces Matcher abstraction. It is an entity that can
+%%% be created from a predicate function or a matcher provided by a supported
+%%% framework (at the moment only Hamcrest is supported). Then it can be used
+%%% to check that an arbitrary value meets the matcher's criteria, matches in
+%%% other words.
+-module(meck_matcher).
+
+-export_type(matcher/0).
+
+%% API
+-export(new/1).
+-export(is_matcher/1).
+-export(match_ignore/2).
+
+-ignore_xref({hamcrest, is_matcher, 1}).
+-ignore_xref({hamcrest, assert_that, 2}).
+
+%%%============================================================================
+%%% Definitions
+%%%============================================================================
+
+-record('$meck.matcher', {type :: predicate | hamcrest,
+                          impl :: predicate() | hamcrest_matchspec()}).
+
+%%%============================================================================
+%%% Types
+%%%============================================================================
+
+-type predicate() :: fun((X::any()) -> any()).
+-type matcher() :: #'$meck.matcher'{}.
+-type hamcrest_matchspec() :: tuple(). %% #'hamcrest.matchspec'{}
+-export_type(hamcrest_matchspec/0).
+
+%%%============================================================================
+%%% API
+%%%============================================================================
+
+-spec new(predicate() | hamcrest_matchspec()) -> matcher().
+new(Predicate) when is_function(Predicate) ->
+    {arity, 1} = erlang:fun_info(Predicate, arity),
+    #'$meck.matcher'{type = predicate, impl = Predicate};
+new(Something) ->
+    case is_hamcrest_matcher(Something) of
+        true ->
+            #'$meck.matcher'{type = hamcrest, impl = Something};
+        _Else ->
+            erlang:error({invalid_matcher, Something})
+    end.
+
+-spec is_matcher(any()) -> boolean().
+is_matcher(#'$meck.matcher'{}) -> true;
+is_matcher(_Other) -> false.
+
+%% @doc If `Something' is a {@link meck_matcher()} instance then `Value' is
+%% matched with it, otherwise `true' is returned effectively ignoring
+%% `Something''s value.
+-spec match_ignore(Value::any(), Something::any()) -> boolean().
+match_ignore(Value, #'$meck.matcher'{type = predicate, impl = Predicate}) ->
+    Predicate(Value) == true;
+match_ignore(Value, #'$meck.matcher'{type = hamcrest, impl = HamcrestMatcher}) ->
+    (catch erlang:apply(hamcrest, assert_that, Value, HamcrestMatcher)) == true;
+match_ignore(_Value, _NotMatcher) ->
+    true.
+
+%%%============================================================================
+%%% Internal functions
+%%%============================================================================
+
+-spec is_hamcrest_matcher(any()) -> boolean().
+is_hamcrest_matcher(Something) ->
+    try erlang:apply(hamcrest, is_matcher, Something)
+    catch _Class:_Reason -> false
+    end.

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/src/meck_proc.erl Added

@@ -0,0 +1,728 @@
+%%%============================================================================
+%%% Licensed under the Apache License, Version 2.0 (the "License");
+%%% you may not use this file except in compliance with the License.
+%%% You may obtain a copy of the License at
+%%%
+%%% http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%% Unless required by applicable law or agreed to in writing, software
+%%% distributed under the License is distributed on an "AS IS" BASIS,
+%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%% See the License for the specific language governing permissions and
+%%% limitations under the License.
+%%%============================================================================
+
+%%% @hidden
+%%% @doc Implements a gen_server that maintains the state of a mocked module.
+%%% The state includes function stubs, call history, etc. Meck starts one such
+%%% process per mocked module.
+-module(meck_proc).
+-behaviour(gen_server).
+
+%% API
+-export(start/2).
+-export(set_expect/2).
+-export(delete_expect/4).
+-export(list_expects/2).
+-export(get_history/1).
+-export(wait/6).
+-export(reset/1).
+-export(validate/1).
+-export(stop/1).
+
+%% To be accessible from generated modules
+-export(get_result_spec/3).
+-export(add_history_exception/5).
+-export(add_history/5).
+-export(invalidate/1).
+
+%% gen_server callbacks
+-export(init/1).
+-export(handle_call/3).
+-export(handle_cast/2).
+-export(handle_info/2).
+-export(terminate/2).
+-export(code_change/3).
+
+%%%============================================================================
+%%% Definitions
+%%%============================================================================
+
+-type meck_dict() :: dict:dict().
+
+-record(state, {mod :: atom(),
+                can_expect :: any | {Mod::atom(), Ari::byte()},
+                expects :: meck_dict(),
+                valid = true :: boolean(),
+                history =  :: meck_history:history() | undefined,
+                original :: term(),
+                was_sticky = false :: boolean(),
+                merge_expects = false :: boolean(),
+                passthrough = false :: boolean(),
+                reload :: {Compiler::pid(), {From::pid(), Tag::any()}} |
+                          undefined,
+                trackers =  :: tracker()}).
+
+-record(tracker, {opt_func :: '_' | atom(),
+                  args_matcher :: meck_args_matcher:args_matcher(),
+                  opt_caller_pid :: '_' | pid(),
+                  countdown :: non_neg_integer(),
+                  reply_to :: {Caller::pid(), Tag::any()},
+                  expire_at :: erlang:timestamp()}).
+
+%%%============================================================================
+%%% Types
+%%%============================================================================
+
+-type tracker() :: #tracker{}.
+
+%%%============================================================================
+%%% API
+%%%============================================================================
+
+-spec start(Mod::atom(), Options::proplists:property()) -> ok | no_return().
+start(Mod, Options) ->
+    StartFunc = case proplists:is_defined(no_link, Options) of
+                    true  -> start;
+                    false -> start_link
+                end,
+    SpawnOpt = proplists:get_value(spawn_opt, Options, ),
+    case gen_server:StartFunc({local, meck_util:proc_name(Mod)}, ?MODULE,
+                              Mod, Options, {spawn_opt, SpawnOpt}) of
+        {ok, _Pid}      -> ok;
+        {error, Reason} -> erlang:error(Reason, Mod, Options)
+    end.
+
+-spec get_result_spec(Mod::atom(), Func::atom(), Args::any()) ->
+        meck_ret_spec:result_spec() | undefined.
+get_result_spec(Mod, Func, Args) ->
+    gen_server(call, Mod, {get_result_spec, Func, Args}).
+
+-spec set_expect(Mod::atom(), meck_expect:expect()) ->
+        ok | {error, Reason::any()}.
+set_expect(Mod, Expect) ->
+    Proc = meck_util:proc_name(Mod),
+    try
+        gen_server:call(Proc, {set_expect, Expect})
+    catch
+        exit:{noproc, _Details} ->
+            Options = Mod, passthrough,
+            case gen_server:start({local, Proc}, ?MODULE, Options, ) of
+                {ok, Pid} ->
+                    Result = gen_server:call(Proc, {set_expect, Expect}),
+                    true = erlang:link(Pid),
+                    Result;
+                {error, {{undefined_module, Mod}, _StackTrace}} ->
+                    erlang:error({not_mocked, Mod})
+            end
+    end.
+
+-spec delete_expect(Mod::atom(), Func::atom(), Ari::byte(), Force::boolean()) -> ok.
+delete_expect(Mod, Func, Ari, Force) ->
+    gen_server(call, Mod, {delete_expect, Func, Ari, Force}).
+
+-spec list_expects(Mod::atom(), ExcludePassthrough::boolean()) ->
+    {Mod::atom(), Func::atom(), Ari::byte()}.
+list_expects(Mod, ExcludePassthrough) ->
+    gen_server(call, Mod, {list_expects, ExcludePassthrough}).
+
+-spec add_history_exception(
+        Mod::atom(), CallerPid::pid(), Func::atom(), Args::any(),
+        {Class::error|exit|throw, Reason::any(), StackTrace::any()}) ->
+        ok.
+add_history_exception(Mod, CallerPid, Func, Args, {Class, Reason, StackTrace}) ->
+    gen_server(cast, Mod, {add_history, {CallerPid, {Mod, Func, Args}, Class, Reason, StackTrace}}).
+
+-spec add_history(Mod::atom(), CallerPid::pid(), Func::atom(), Args::any(),
+                  Result::any()) ->
+        ok.
+add_history(Mod, CallerPid, Func, Args, Result) ->
+    gen_server(cast, Mod, {add_history, {CallerPid, {Mod, Func, Args}, Result}}).
+
+-spec get_history(Mod::atom()) -> meck_history:history().
+get_history(Mod) ->
+    gen_server(call, Mod, get_history).
+
+-spec wait(Mod::atom(),
+           Times::non_neg_integer(),
+           OptFunc::'_' | atom(),
+           meck_args_matcher:args_matcher(),
+           OptCallerPid::'_' | pid(),
+           Timeout::non_neg_integer()) ->
+        ok.
+wait(Mod, Times, OptFunc, ArgsMatcher, OptCallerPid, Timeout) ->
+    EffectiveTimeout = case Timeout of
+                           0 ->
+                               infinity;
+                           _Else ->
+                               Timeout
+                       end,
+    Name = meck_util:proc_name(Mod),
+    try gen_server:call(Name, {wait, Times, OptFunc, ArgsMatcher, OptCallerPid,
+                               Timeout},
+                        EffectiveTimeout)
+    of
+        ok ->
+            ok;
+        {error, timeout} ->
+            erlang:error(timeout)
+    catch
+        exit:{timeout, _Details} ->
+            erlang:error(timeout);
+        exit:_Reason ->
+            erlang:error({not_mocked, Mod})
+    end.
+
+-spec reset(Mod::atom()) -> ok.
+reset(Mod) ->
+    gen_server(call, Mod, reset).
+
+-spec validate(Mod::atom()) -> boolean().
+validate(Mod) ->
+    gen_server(call, Mod, validate).
+
+-spec invalidate(Mod::atom()) -> ok.
+invalidate(Mod) ->
+    gen_server(cast, Mod, invalidate).
+
+-spec stop(Mod::atom()) -> ok.
+stop(Mod) ->
+    gen_server(call, Mod, stop).
+
+%%%============================================================================
+%%% gen_server callbacks
+%%%============================================================================
+
+%% @hidden
+validate_options() -> ok;
+validate_options(no_link|Options) -> validate_options(Options);
+validate_options(spawn_opt|Options) -> validate_options(Options);

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/src/meck_ret_spec.erl Added

@@ -0,0 +1,144 @@
+%%%============================================================================
+%%% Licensed under the Apache License, Version 2.0 (the "License");
+%%% you may not use this file except in compliance with the License.
+%%% You may obtain a copy of the License at
+%%%
+%%% http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%% Unless required by applicable law or agreed to in writing, software
+%%% distributed under the License is distributed on an "AS IS" BASIS,
+%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%% See the License for the specific language governing permissions and
+%%% limitations under the License.
+%%%============================================================================
+
+%%% @private
+%%% @doc Provides expectation processing functions.
+-module(meck_ret_spec).
+
+-export_type(result_spec/0).
+-export_type(ret_spec/0).
+
+%% API
+-export(passthrough/0).
+-export(val/1).
+-export(exec/1).
+-export(seq/1).
+-export(loop/1).
+-export(raise/2).
+-export(is_meck_exception/1).
+-export(is_passthrough/1).
+-export(retrieve_result/1).
+-export(eval_result/4).
+
+%%%============================================================================
+%%% Types
+%%%============================================================================
+
+-opaque result_spec() :: {meck_value, any()} |
+                         {meck_exec, fun()} |
+                         {meck_raise, Class::throw | error | exit, Reason::any()} |
+                         meck_passthrough.
+
+-type ret_spec() :: {meck_seq, ret_spec()} |
+                    {meck_loop, ret_spec(), ret_spec()} |
+                    result_spec() |
+                    any().
+
+%%%============================================================================
+%%% API
+%%%============================================================================
+
+-spec passthrough() -> ret_spec().
+passthrough() -> meck_passthrough.
+
+-spec val(any()) -> ret_spec().
+val(Value) -> {meck_value, Value}.
+
+-spec exec(fun()) -> ret_spec().
+exec(Fun) when is_function(Fun)-> {meck_exec, Fun}.
+
+-spec seq(ret_spec()) -> ret_spec().
+seq(Sequence) when is_list(Sequence) -> {meck_seq, Sequence}.
+
+-spec loop(ret_spec()) -> ret_spec().
+loop(Loop) when is_list(Loop) -> {meck_loop, Loop, Loop}.
+
+-spec raise(Class:: throw | error | exit, Reason::any()) -> ret_spec().
+raise(throw, Reason) -> {meck_raise, throw, Reason};
+raise(error, Reason) -> {meck_raise, error, Reason};
+raise(exit, Reason) -> {meck_raise, exit, Reason}.
+
+-spec is_meck_exception(Reason::any()) -> {true, any(), any()} | false.
+is_meck_exception({meck_raise, MockedClass, MockedReason}) ->
+    {true, MockedClass, MockedReason};
+is_meck_exception(_Reason) ->
+    false.
+
+-spec is_passthrough(ret_spec()) -> boolean().
+is_passthrough(RetSpec) -> RetSpec == meck_passthrough.
+
+-spec retrieve_result(RetSpec::ret_spec()) ->
+        {result_spec(), NewRetSpec::ret_spec() | unchanged}.
+retrieve_result(RetSpec) ->
+    retrieve_result(RetSpec, ).
+
+-spec eval_result(Mod::atom(), Func::atom(), Args::any(), result_spec()) ->
+        Result::any().
+eval_result(_Mod, _Func, _Args, {meck_value, Value}) ->
+    Value;
+eval_result(_Mod, _Func, Args, {meck_exec, Fun}) when is_function(Fun) ->
+    erlang:apply(Fun, Args);
+eval_result(_Mod, _Func, _Args, MockedEx = {meck_raise, _Class, _Reason}) ->
+    erlang:throw(MockedEx);
+eval_result(Mod, Func, Args, meck_passthrough) ->
+    erlang:apply(meck_util:original_name(Mod), Func, Args).
+
+%%%============================================================================
+%%% Internal functions
+%%%============================================================================
+
+-spec retrieve_result(RetSpec::ret_spec(), ExplodedRs::ret_spec()) ->
+        {result_spec(), NewRetSpec::ret_spec() | unchanged}.
+retrieve_result(RetSpec = {meck_seq, InnerRs | _Rest}, ExplodedRs) ->
+    retrieve_result(InnerRs, RetSpec | ExplodedRs);
+retrieve_result(RetSpec = {meck_loop, InnerRs | _Rest, _Loop}, ExplodedRs) ->
+    retrieve_result(InnerRs, RetSpec | ExplodedRs);
+retrieve_result(RetSpec, ExplodedRs) ->
+    ResultSpec = case is_result_spec(RetSpec) of
+                     true ->
+                         RetSpec;
+                     _ when erlang:is_function(RetSpec) ->
+                         exec(RetSpec);
+                     _ ->
+                         val(RetSpec)
+                 end,
+    {ResultSpec, update_rs(RetSpec, ExplodedRs, false)}.
+
+-spec is_result_spec(any()) -> boolean().
+is_result_spec({meck_value, _Value}) -> true;
+is_result_spec({meck_exec, _Fun}) -> true;
+is_result_spec({meck_raise, _Class, _Reason}) -> true;
+is_result_spec(meck_passthrough) -> true;
+is_result_spec(_Other) -> false.
+
+-spec update_rs(InnerRs::ret_spec(), ExplodedRs::ret_spec(), Done::boolean()) ->
+        NewRetSpec::ret_spec() | unchanged.
+update_rs(InnerRs, , true) ->
+    InnerRs;
+update_rs(_InnerRs, , false) ->
+    unchanged;
+update_rs(InnerRs, CurrRs = {meck_seq, InnerRs} | ExplodedRs, Updated) ->
+    update_rs(CurrRs, ExplodedRs, Updated);
+update_rs(InnerRs, {meck_seq, InnerRs | Rest} | ExplodedRs, _Updated) ->
+    update_rs({meck_seq, Rest}, ExplodedRs, true);
+update_rs(NewInnerRs, {meck_seq, _InnerRs | Rest} | ExplodedRs, _Updated) ->
+    update_rs({meck_seq, NewInnerRs | Rest}, ExplodedRs, true);
+update_rs(InnerRs, {meck_loop, InnerRs, Loop} | ExplodedRs, _Updated) ->
+    update_rs({meck_loop, Loop, Loop}, ExplodedRs, true);
+update_rs(InnerRs, {meck_loop, InnerRs | Rest, Loop} | ExplodedRs,
+             _Updated) ->
+    update_rs({meck_loop, Rest, Loop}, ExplodedRs, true);
+update_rs(NewInnerRs, {meck_loop, _InnerRs | Rest, Loop} | ExplodedRs,
+             _Updated) ->
+    update_rs({meck_loop, NewInnerRs | Rest, Loop}, ExplodedRs, true).

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/src/meck_util.erl Added

@@ -0,0 +1,44 @@
+%%%============================================================================
+%%% Licensed under the Apache License, Version 2.0 (the "License");
+%%% you may not use this file except in compliance with the License.
+%%% You may obtain a copy of the License at
+%%%
+%%% http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%% Unless required by applicable law or agreed to in writing, software
+%%% distributed under the License is distributed on an "AS IS" BASIS,
+%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%% See the License for the specific language governing permissions and
+%%% limitations under the License.
+%%%============================================================================
+
+%%% @private
+%%% @doc Contains utility functions that used around other meck modules.
+-module(meck_util).
+
+%% API
+-export_type(match_spec_item/0).
+
+-export(proc_name/1).
+-export(original_name/1).
+-export(match_spec_item/1).
+
+%%%============================================================================
+%%% Types
+%%%============================================================================
+
+-type match_spec_item() :: {Pattern::tuple(), Guards::any(), Result::any()}.
+
+%%%============================================================================
+%%% API
+%%%============================================================================
+
+-spec proc_name(Mod::atom()) -> MockMod::atom().
+proc_name(Name) -> list_to_atom(atom_to_list(Name) ++ "_meck").
+
+-spec original_name(Mod::atom()) -> OrigMod::atom().
+original_name(Name) -> list_to_atom(atom_to_list(Name) ++ "_meck_original").
+
+-spec match_spec_item(Pattern::tuple()) -> match_spec_item().
+match_spec_item(Pattern) ->
+    {Pattern, , '$_'}.

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/test Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/test/cover_test_module.dontcompile Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/test/include Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/test/include/cover_test.hrl Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/test/meck_args_matcher_tests.erl Added

@@ -0,0 +1,59 @@
+%%%============================================================================
+%%% Licensed under the Apache License, Version 2.0 (the "License");
+%%% you may not use this file except in compliance with the License.
+%%% You may obtain a copy of the License at
+%%%
+%%% http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%% Unless required by applicable law or agreed to in writing, software
+%%% distributed under the License is distributed on an "AS IS" BASIS,
+%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%% See the License for the specific language governing permissions and
+%%% limitations under the License.
+%%%============================================================================
+-module(meck_args_matcher_tests).
+
+-include_lib("eunit/include/eunit.hrl").
+
+from_wildcard_test() ->
+    ArgsMatcher = meck_args_matcher:new('_'),
+    ?assertMatch(true, meck_args_matcher:match(, ArgsMatcher)),
+    ?assertMatch(true, meck_args_matcher:match(1, ArgsMatcher)),
+    ?assertMatch(true, meck_args_matcher:match(1, 2, 3, ArgsMatcher)).
+
+from_arity_test() ->
+    ArgsMatcher = meck_args_matcher:new(3),
+    ?assertMatch(true,  meck_args_matcher:match(1, 2, 3, ArgsMatcher)),
+    ?assertMatch(false, meck_args_matcher:match(1, 2, ArgsMatcher)),
+    ?assertMatch(false, meck_args_matcher:match(1, 2, 3, 4, ArgsMatcher)).
+
+from_zero_arity_test() ->
+    ArgsMatcher = meck_args_matcher:new(0),
+    ?assertMatch(true,  meck_args_matcher:match(, ArgsMatcher)),
+    ?assertMatch(false, meck_args_matcher:match(1, 2, 3, ArgsMatcher)).
+
+from_args_test() ->
+    ArgsMatcher = meck_args_matcher:new(1, {2, <<"3">>}),
+    ?assertMatch(true,  meck_args_matcher:match(1, {2, <<"3">>}, ArgsMatcher)),
+    ?assertMatch(false, meck_args_matcher:match(1, {2, <<"3">>}, 1, ArgsMatcher)),
+    ?assertMatch(false, meck_args_matcher:match(1, {0, <<"3">>}, ArgsMatcher)).
+
+from_empty_args_test() ->
+    ArgsMatcher = meck_args_matcher:new(),
+    ?assertMatch(true,  meck_args_matcher:match(, ArgsMatcher)),
+    ?assertMatch(false, meck_args_matcher:match(1, 2, 3, ArgsMatcher)).
+
+matcher_featured_test() ->
+    ArgsSpec = meck:is(fun(X) -> X == 1 end),
+                2,
+                meck:is(fun(X) -> X == 3 end),
+                {4, 5, '_', <<"7">>},
+    ArgsMatcher = meck_args_matcher:new(ArgsSpec),
+    ?assertMatch(true,  meck_args_matcher:match(1, 2, 3, {4, 5, 6, <<"7">>}, ArgsMatcher)),
+    ?assertMatch(false, meck_args_matcher:match(0, 2, 3, {4, 5, 6, <<"7">>}, ArgsMatcher)),
+    ?assertMatch(false, meck_args_matcher:match(1, 0, 3, {4, 5, 6, <<"7">>}, ArgsMatcher)),
+    ?assertMatch(false, meck_args_matcher:match(1, 2, 0, {4, 5, 6, <<"7">>}, ArgsMatcher)),
+    ?assertMatch(false, meck_args_matcher:match(1, 2, 3, {0, 5, 6, <<"7">>}, ArgsMatcher)),
+    ?assertMatch(false, meck_args_matcher:match(1, 2, 3, {4, 0, 6, <<"7">>}, ArgsMatcher)),
+    ?assertMatch(true,  meck_args_matcher:match(1, 2, 3, {4, 5, 0, <<"7">>}, ArgsMatcher)),
+    ?assertMatch(false, meck_args_matcher:match(1, 2, 3, {4, 5, 6, <<"0">>}, ArgsMatcher)).

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/test/meck_expect_tests.erl Added

@@ -0,0 +1,107 @@
+%%%============================================================================
+%%% Copyright 2010-2017 Adam Lindberg, 2010-2011 Erlang Solutions Ltd
+%%%
+%%% Licensed under the Apache License, Version 2.0 (the "License");
+%%% you may not use this file except in compliance with the License.
+%%% You may obtain a copy of the License at
+%%%
+%%% http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%% Unless required by applicable law or agreed to in writing, software
+%%% distributed under the License is distributed on an "AS IS" BASIS,
+%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%% See the License for the specific language governing permissions and
+%%% limitations under the License.
+%%%============================================================================
+-module(meck_expect_tests).
+
+-include_lib("eunit/include/eunit.hrl").
+
+expect_explicit_values_test() ->
+    %% When
+    E = meck_expect:new(blah, 1000, a, {1002, {<<"b">>, 1003}}, 2001),
+    %% Then
+    V2001 = meck_ret_spec:val(2001),
+    ?assertMatch({V2001, _},
+                 meck_expect:fetch_result(1000, a, {1002, {<<"b">>, 1003}}, E)),
+    ?assertMatch({undefined, _},
+                 meck_expect:fetch_result(1001, a, {1002, {<<"b">>, 1003}}, E)),
+    ?assertMatch({undefined, _},
+                 meck_expect:fetch_result(1000, b, {1002, {<<"b">>, 1003}}, E)),
+    ?assertMatch({undefined, _},
+                 meck_expect:fetch_result(1000, a, {1003, {<<"b">>, 1003}}, E)),
+    ?assertMatch({undefined, _},
+                 meck_expect:fetch_result(1000, a, {1002, {<<"c">>, 1003}}, E)),
+    ?assertMatch({undefined, _},
+                 meck_expect:fetch_result(1000, a, {1002, {<<"b">>, 1004}}, E)).
+
+expect_wildcard_test() ->
+    %% When
+    E = meck_expect:new(blah, 1000, '_', {'_', {'_', 1003}}, 2001),
+    %% Then
+    V2001 = meck_ret_spec:val(2001),
+    ?assertMatch({V2001, _},
+                 meck_expect:fetch_result(1000, a, {1002, {<<"b">>, 1003}}, E)),
+    ?assertMatch({undefined, _},
+                 meck_expect:fetch_result(1001, a, {1002, {<<"b">>, 1003}}, E)),
+    ?assertMatch({V2001, _},
+                 meck_expect:fetch_result(1000, b, {1002, {<<"b">>, 1003}}, E)),
+    ?assertMatch({V2001, _},
+                 meck_expect:fetch_result(1000, a, {1003, {<<"b">>, 1003}}, E)),
+    ?assertMatch({V2001, _},
+                 meck_expect:fetch_result(1000, a, {1002, {1, {2}, 3, 1003}}, E)),
+    ?assertMatch({undefined, _},
+                 meck_expect:fetch_result(1000, a, {1002, {<<"b">>, 1004}}, E)).
+
+expect_matchers_test() ->
+    %% Given
+    Is1003 = meck_matcher:new(fun(X) -> X == 1003 end),
+    LessThen1004 = meck_matcher:new(fun(X) -> X < 1004 end),
+    %% When
+    E = meck_expect:new(blah, Is1003, LessThen1004, 2001),
+    %% Then
+    V2001 = meck_ret_spec:val(2001),
+    ?assertMatch({V2001, _},     meck_expect:fetch_result(1003, 1002, E)),
+    ?assertMatch({V2001, _},     meck_expect:fetch_result(1003, 1003, E)),
+    ?assertMatch({undefined, _}, meck_expect:fetch_result(1003, 1004, E)),
+    ?assertMatch({undefined, _}, meck_expect:fetch_result(1002, 1002, E)).
+
+expect_with_matchers_multiclause_test() ->
+    %% Given
+    Is1003 = meck_matcher:new(fun(X) -> X == 1003 end),
+    LessThen1004 = meck_matcher:new(fun(X) -> X < 1004 end),
+    %% When
+    E = meck_expect:new(blah, {'_', Is1003, 1004,         2001},
+                               {'_', Is1003, LessThen1004, 2002},
+                               {'_', '_',    LessThen1004, 2003}),
+    %% Then
+    V2001 = meck_ret_spec:val(2001),
+    ?assertMatch({V2001, _},
+                 meck_expect:fetch_result(1002, 1003, 1004, E)),
+    V2002 = meck_ret_spec:val(2002),
+    ?assertMatch({V2002, _},
+                 meck_expect:fetch_result(1002, 1003, 1003, E)),
+    V2003 = meck_ret_spec:val(2003),
+    ?assertMatch({V2003, _},
+                 meck_expect:fetch_result(1002, 1004, 1003, E)),
+    ?assertMatch({undefined, _},
+                 meck_expect:fetch_result(1002, 1003, 1005, E)).
+
+expect_with_matchers_masked_clause_test() ->
+    %% Given
+    Is1003 = meck_matcher:new(fun(X) -> X == 1003 end),
+    LessThen1004 = meck_matcher:new(fun(X) -> X < 1004 end),
+    %% When
+    E = meck_expect:new(blah, {Is1003, LessThen1004, 2001},
+                               {Is1003, Is1003, 2002}),
+    %% Then
+    V2001 = meck_ret_spec:val(2001),
+    ?assertMatch({V2001, _}, meck_expect:fetch_result(1003, 1003, E)).
+
+expect_with_arity_test() ->
+    %% When
+    E = meck_expect:new(foo, {2, 2001}),
+    %% Then
+    V2001 = meck_ret_spec:val(2001),
+    ?assertMatch({V2001, _}, meck_expect:fetch_result(1, 2, E)),
+    ?assertMatch({undefined, _}, meck_expect:fetch_result(1, 2, 3, E)).

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/test/meck_history_tests.erl Added

@@ -0,0 +1,184 @@
+%%%============================================================================
+%%% Copyright 2013 Maxim Vladimirsky
+%%%
+%%% Licensed under the Apache License, Version 2.0 (the "License");
+%%% you may not use this file except in compliance with the License.
+%%% You may obtain a copy of the License at
+%%%
+%%% http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%% Unless required by applicable law or agreed to in writing, software
+%%% distributed under the License is distributed on an "AS IS" BASIS,
+%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%% See the License for the specific language governing permissions and
+%%% limitations under the License.
+%%%============================================================================
+
+-module(meck_history_tests).
+
+-include_lib("eunit/include/eunit.hrl").
+
+history_test_() ->
+    {foreach, fun setup/0, fun teardown/1, 
+        fun num_calls_with_arity/0,
+        fun capture_different_positions/0,
+        fun capture_different_args_specs/0,
+        fun result_different_positions/0,
+        fun result_different_args_specs/0,
+        fun result_exception/0,
+        fun result_different_caller/0,
+        fun history_kept_while_reloading/0
+    }.
+
+setup() ->
+    %% Given
+    meck:new(test, non_strict),
+    ok.
+
+teardown(_) ->
+    %% Cleanup
+    meck:unload().
+
+num_calls_with_arity() ->
+    meck:expect(test, foo, 2, ok),
+    meck:expect(test, foo, 3, ok),
+    %% When
+    test:foo(1, 2, 3),
+    test:foo(1, 2),
+    test:foo(1, 2, 3),
+    test:foo(1, 2, 3),
+    test:foo(1, 2),
+    %% Then
+    ?assertMatch(2, meck:num_calls(test, foo, 2)),
+    ?assertMatch(3, meck:num_calls(test, foo, 3)),
+    ?assertMatch(0, meck:num_calls(test, foo, 4)).
+
+capture_different_positions() ->
+    meck:expect(test, foo, 3, ok),
+    meck:expect(test, foo, 4, ok),
+    meck:expect(test, bar, 3, ok),
+    test:foo(1001, 2001, 3001, 4001),
+    test:bar(1002, 2002, 3002),
+    test:foo(1003, 2003, 3003),
+    test:bar(1004, 2004, 3004),
+    test:foo(1005, 2005, 3005),
+    test:foo(1006, 2006, 3006),
+    test:bar(1007, 2007, 3007),
+    test:foo(1008, 2008, 3008),
+    %% When/Then
+    ?assertMatch(2003, meck:capture(first, test, foo, '_', '_', '_', 2)),
+    ?assertMatch(2008, meck:capture(last, test, foo, '_', '_', '_', 2)),
+    ?assertMatch(2006, meck:capture(3, test, foo, '_', '_', '_', 2)),
+    ?assertError(not_found, meck:capture(5, test, foo, '_', '_', '_', 2)).
+
+capture_different_args_specs() ->
+    meck:expect(test, foo, 2, ok),
+    meck:expect(test, foo, 3, ok),
+    meck:expect(test, foo, 4, ok),
+    meck:expect(test, bar, 3, ok),
+    test:foo(1001, 2001, 3001, 4001),
+    test:bar(1002, 2002, 3002),
+    test:foo(1003, 2003, 3003),
+    test:bar(1004, 2004, 3004),
+    test:foo(1005, 2005),
+    test:foo(1006, 2006, 3006),
+    test:bar(1007, 2007, 3007),
+    test:foo(1008, 2008, 3008),
+    %% When/Then
+    ?assertMatch(2001, meck:capture(first, test, foo, '_', 2)),
+    ?assertMatch(2003, meck:capture(first, test, foo, 3, 2)),
+    ?assertMatch(2005, meck:capture(first, test, foo, '_', '_', 2)),
+    ?assertMatch(2006, meck:capture(first, test, foo, 1006, '_', '_', 2)),
+    ?assertMatch(2008, meck:capture(first, test, foo, '_', '_', meck:is(fun(X) -> X > 3006 end), 2)).
+
+result_different_positions() ->
+    meck:expect(test, foo, fun(_, A, _) -> A end),
+    meck:expect(test, foo, 4, ok),
+    meck:expect(test, bar, 3, ok),
+    %% When
+    test:foo(1001, 2001, 3001, 4001),
+    test:bar(1002, 2002, 3002),
+    test:foo(1003, 2003, 3003),
+    test:bar(1004, 2004, 3004),
+    test:foo(1005, 2005, 3005),
+    test:foo(1006, 2006, 3006),
+    test:bar(1007, 2007, 3007),
+    test:foo(1008, 2008, 3008),
+    %% Then
+    ?assertMatch(2003, meck_history:result(first, '_', test, foo, '_', '_', '_')),
+    ?assertMatch(2008, meck_history:result(last, '_', test, foo, '_', '_', '_')),
+    ?assertMatch(2006, meck_history:result(3, '_', test, foo, '_', '_', '_')),
+    ?assertError(not_found, meck_history:result(5, '_', test, foo, '_', '_', '_')).
+
+result_different_args_specs() ->
+    meck:expect(test, foo, fun(_, A) -> A end),
+    meck:expect(test, foo, fun(_, A, _) -> A end),
+    meck:expect(test, foo, fun(_, A, _, _) -> A end),
+    meck:expect(test, bar, 3, ok),
+    %% When
+    test:foo(1001, 2001, 3001, 4001),
+    test:bar(1002, 2002, 3002),
+    test:foo(1003, 2003, 3003),
+    test:bar(1004, 2004, 3004),
+    test:foo(1005, 2005),
+    test:foo(1006, 2006, 3006),
+    test:bar(1007, 2007, 3007),
+    test:foo(1008, 2008, 3008),
+    %% Then
+    ?assertMatch(2001, meck_history:result(first, '_', test, foo, '_')),
+    ?assertMatch(2003, meck_history:result(first, '_', test, foo, 3)),
+    ?assertMatch(2005, meck_history:result(first, '_', test, foo, '_', '_')),
+    ?assertMatch(2006, meck_history:result(first, '_', test, foo, 1006, '_', '_')),
+    Matcher = meck:is(fun(X) -> X > 3006 end),
+    ?assertMatch(2008, meck_history:result(first, '_', test, foo, '_', '_', Matcher)).
+
+result_exception() ->
+    meck:expect(test, error, fun(R) -> erlang:error(R) end),
+    meck:expect(test, throw, fun(R) -> throw(R) end),
+    meck:expect(test, exit, fun(R) -> exit(R) end),
+    %% When
+    catch test:error(foo),
+    catch test:throw(bar),
+    catch test:exit(baz),
+    %% Then
+    ?assertException(error, foo, meck_history:result(first, '_', test, error, 1)),
+    ?assertException(throw, bar, meck_history:result(first, '_', test, throw, 1)),
+    ?assertException(exit, baz, meck_history:result(first, '_', test, exit, 1)),
+    ?assertError(not_found, meck_history:result(first, '_', test, foo, 0)).
+
+result_different_caller() ->
+    meck:expect(test, foo, fun(_, A, _) -> A end),
+    %% When
+    test:foo(1001, 2001, 3001),
+    Self = self(),
+    Pid = spawn(fun() ->
+                        test:foo(1002, 2002, 3002),
+                        Self ! {self(), done}
+                end),
+    test:foo(1003, 2003, 3003),
+    receive {Pid, done} -> ok end,
+    %% Then
+    ?assertMatch(2003, meck_history:result(2, self(), test, foo, 3)),
+    ?assertMatch(2002, meck_history:result(last, Pid, test, foo, 3)).
+
+history_kept_while_reloading() ->
+    NumCalls = 10,
+    meck:new(historical, non_strict, passthrough),
+    meck:expect(historical, test_fn, fun(Arg) -> {mocked, Arg} end),
+    Test = self(),
+    Caller = spawn(fun() ->
+        io:format("~nCalls: ~p~n", lists:reverse(lists:foldl(fun(N, Acc) ->
+            timer:sleep(1),
+            Result = historical:test_fn(N),
+            {self(), {historical, test_fn, N}, Result}|Acc
+        end, , lists:seq(1, NumCalls)))),
+        Test ! {done, self()}
+    end),
+    
+        meck:expect(historical, test_fn, fun(Arg) -> {mocked2, Arg} end)
+        || _ <- lists:seq(1, 5)
+    ,
+
+    receive {done, Caller} -> ok after 1000 -> error(caller_timeout) end,
+    io:format("History: ~p~n", meck:history(historical)),
+    ?assertEqual(NumCalls, meck:num_calls(historical, test_fn, '_')).

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/test/meck_matcher_tests.erl Added

@@ -0,0 +1,46 @@
+%%%============================================================================
+%%% Licensed under the Apache License, Version 2.0 (the "License");
+%%% you may not use this file except in compliance with the License.
+%%% You may obtain a copy of the License at
+%%%
+%%% http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%% Unless required by applicable law or agreed to in writing, software
+%%% distributed under the License is distributed on an "AS IS" BASIS,
+%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%% See the License for the specific language governing permissions and
+%%% limitations under the License.
+%%%============================================================================
+-module(meck_matcher_tests).
+
+-include_lib("eunit/include/eunit.hrl").
+
+match_predicate_test() ->
+    Matcher = meck_matcher:new(fun(X) -> X == 1000 end),
+    ?assertMatch(true, meck_matcher:match_ignore(1000, Matcher)),
+    ?assertMatch(false, meck_matcher:match_ignore(1001, Matcher)).
+
+match_predicate_not_bool_test() ->
+    Matcher = meck_matcher:new(fun(1000) -> true;
+        (Other) -> Other
+                               end),
+    ?assertMatch(true, meck_matcher:match_ignore(1000, Matcher)),
+    ?assertMatch(false, meck_matcher:match_ignore(1001, Matcher)).
+
+match_hamcrest_test() ->
+    Matcher = meck_matcher:new(fun(X) -> X == 1000 end),
+    ?assertMatch(true, meck_matcher:match_ignore(1000, Matcher)),
+    ?assertMatch(false, meck_matcher:match_ignore(1001, Matcher)).
+
+match_not_matcher_test() ->
+    ?assertMatch(true, meck_matcher:match_ignore(something, '_')),
+    ?assertMatch(true, meck_matcher:match_ignore({1, 2, 3, undefined}, {1, 2, 3, undefined})).
+
+predicate_wrong_arity_test() ->
+    Predicate = fun(X, Y) -> X == Y end,
+    ?assertError(_, meck_matcher:new(Predicate)).
+
+is_matcher_test() ->
+    ?assertMatch(true, meck_matcher:is_matcher(meck_matcher:new(fun(X) -> X == 1000 end))),
+    ?assertMatch(false, meck_matcher:is_matcher(fun(X) -> X == 1000 end)),
+    ?assertMatch(false, meck_matcher:is_matcher(blah)).

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/test/meck_on_load_module.erl Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/test/meck_on_load_tests.erl Added

@@ -0,0 +1,40 @@
+-module(meck_on_load_tests).
+
+-include_lib("eunit/include/eunit.hrl").
+
+on_load_test_() ->
+    {foreach, fun setup/0, fun teardown/1,
+     fun no_enable_on_load/0,
+      fun enable_on_load/0}.
+
+setup() ->
+    ok.
+
+teardown(_) ->
+    meck:unload().
+
+no_enable_on_load() ->
+    % We _don't_ want on_load to be called. Listen out for it.
+    register(on_load_listener, self()),
+    meck:new(meck_on_load_module, passthrough),
+    ?assertEqual(pong, meck_on_load_module:ping()),
+    receive
+        on_load_called -> erlang:error(unexpected_call_to_on_load)
+    after 100 ->
+              % Use a relatively short timeout, because the happy path goes
+              % through here.
+              ok
+    end.
+
+enable_on_load() ->
+    % We _do_ want on_load to be called.
+    register(on_load_listener, self()),
+    meck:new(meck_on_load_module, passthrough, enable_on_load),
+    ?assertEqual(pong, meck_on_load_module:ping()),
+    receive
+        on_load_called -> ok
+    after 200 ->
+              % Use a longer timeout, because testing for not-called is harder,
+              % and this is the sad path.
+              erlang:error(expected_call_to_on_load)
+    end.

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/test/meck_performance_test.erl Added

@@ -0,0 +1,72 @@
+%% @doc
+-module(meck_performance_test).
+
+%% Interface exports
+-export(run/0).
+-export(run/1).
+-export(run/2).
+-export(new_unload/3).
+
+%%=============================================================================
+%% Interface exports
+%%=============================================================================
+
+run() -> run(meck, 100).
+run(N) -> run(meck, N).
+run(Mod, N) ->
+    header(Mod),
+    run("new+unload", ?MODULE, new_unload, Mod, test, non_strict, N),
+    Mod:new(test, non_strict),
+    run("expect/3", Mod, expect, test, normal, fun() -> ok end, N),
+    run("expect/3+args", Mod, expect, test, normal_args,
+      fun(_, _) -> ok end, N),
+    run("expect/4", Mod, expect, test, shortcut, 0, ok, N),
+    run("expect/4+args", Mod, expect, test, shortcut_args, 2, ok, N),
+
+    header("calls"),
+    Mod:expect(test, shortcut_opaque, 0, self()),
+    run("normal", test, normal, , N),
+    run("normal_args", test, normal_args, a, b, N),
+    run("shortcut", test, shortcut, , N),
+    run("shortcut_args", test, shortcut_args, a, b, N),
+    run("shortcut_opaque", test, shortcut_opaque, , N),
+    Mod:unload(test),
+
+    header("history"),
+    Mod:new(test, non_strict),
+    Mod:expect(test, func, 1, ok),
+    test:func(I) || I <- lists:seq(1, 100),
+    run("called", Mod, called, test, func, 50, N),
+    Mod:unload(test),
+    ok.
+
+new_unload(Mod, Mock, Opts) ->
+    Mod:new(Mock, Opts),
+    Mod:unload(Mock).
+
+%%=============================================================================
+%% Internal functions
+%%=============================================================================
+
+header(Name) ->
+    io:format("~n~s\t\tMin\tMax\tMed\tAvg~n", Name),
+    io:format("------------------------------------------------~n").
+
+run(Name, M, F, A, N) ->
+    io:fwrite("~-16s", Name),
+    io:format("~p\t~p\t~p\t~p~n", test_avg(M, F, A, N)).
+
+test_avg(M, F, A, N) when N > 0 ->
+    L = test_loop(M, F, A, N, ),
+    Length = length(L),
+    Min = lists:min(L),
+    Max = lists:max(L),
+    Med = lists:nth(round((Length / 2)), lists:sort(L)),
+    Avg = round(lists:foldl(fun(X, Sum) -> X + Sum end, 0, L) / Length),
+    Min, Max, Med, Avg.
+
+test_loop(_M, _F, _A, 0, List) ->
+    List;
+test_loop(M, F, A, N, List) ->
+    {T, _Result} = timer:tc(M, F, A),
+    test_loop(M, F, A, N - 1, T|List).

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/test/meck_ret_spec_tests.erl Added

@@ -0,0 +1,67 @@
+%%%============================================================================
+%%% Copyright 2010-2017 Adam Lindberg, 2010-2011 Erlang Solutions Ltd
+%%%
+%%% Licensed under the Apache License, Version 2.0 (the "License");
+%%% you may not use this file except in compliance with the License.
+%%% You may obtain a copy of the License at
+%%%
+%%% http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%% Unless required by applicable law or agreed to in writing, software
+%%% distributed under the License is distributed on an "AS IS" BASIS,
+%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%% See the License for the specific language governing permissions and
+%%% limitations under the License.
+%%%============================================================================
+-module(meck_ret_spec_tests).
+
+-include_lib("eunit/include/eunit.hrl").
+
+ret_spec_test_() ->
+    {foreach, fun setup/0, fun teardown/1,
+     fun passthrough/0,
+      fun explicit_exec/0,
+      fun exec/0,
+      fun deep_exec/0,
+      fun invalid_arity_exec/0
+     
+    }.
+
+setup() ->
+    %% Given
+    meck:new(meck_test_module),
+    ok.
+
+teardown(_) ->
+    %% Cleanup
+    meck:unload().
+
+passthrough() ->
+    %% When
+    meck:expect(meck_test_module, c, 2, meck:passthrough()),
+    %% Then
+    ?assertEqual({1, 3}, meck_test_module:c(1, 3)).
+
+explicit_exec() ->
+    %% When
+    meck:expect(meck_test_module, c, 2, meck:exec(fun(A, B) -> {B, A} end)),
+    %% Then
+    ?assertEqual({3, 1}, meck_test_module:c(1, 3)).
+
+exec() ->
+    %% When
+    meck:expect(meck_test_module, c, 2, fun(A, B) -> {B, A} end),
+    %% Then
+    ?assertEqual({3, 1}, meck_test_module:c(1, 3)).
+
+deep_exec() ->
+    %% When
+    meck:expect(meck_test_module, c, 2, meck_ret_spec:seq(fun(A, B) -> {B, A} end)),
+    %% Then
+    ?assertEqual({3, 1}, meck_test_module:c(1, 3)).
+
+invalid_arity_exec() ->
+    %% When
+    meck:expect(meck_test_module, c, 2, meck_ret_spec:seq(fun(A, B) -> {B, A} end)),
+    %% Then
+    ?assertError(undef, meck_test_module:c(1, 2, 3)).

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/test/meck_test_module.erl Added

osmo-s1gw_0.1.1.54.d545.tar.xz/_checkouts/meck/test/meck_tests.erl Added

@@ -0,0 +1,1701 @@
+%%=============================================================================
+%% Copyright 2010-2017 Adam Lindberg, 2010-2011 Erlang Solutions Ltd
+%%
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%% http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%=============================================================================
+
+-module(meck_tests).
+
+-include_lib("eunit/include/eunit.hrl").
+-include("../src/meck.hrl").
+
+-define(assertTerminated(MonitorRef, Reason, Timeout),
+        (fun() ->
+                receive
+                    {'DOWN', MonitorRef, process, _Pid, Reason} ->
+                         ok;
+                    {'DOWN', MonitorRef, process, _Pid, AnotherReason} ->
+                        erlang:error({dead_for_another_reason, AnotherReason})
+                after
+                    Timeout ->
+                        erlang:error(still_alive)
+                end
+         end)()).
+
+meck_test_() ->
+    {foreach, fun setup/0, fun teardown/1,
+     {with, T} || T <- fun new_/1,
+                           fun unload_/1,
+                           fun double_new_/1,
+                           fun validate_/1,
+                           fun expect_/1,
+                           fun exports_/1,
+                           fun call_return_value_/1,
+                           fun call_return_value_improper_list_/1,
+                           fun call_argument_/1,
+                           fun call_undef_/1,
+                           fun call_function_clause_/1,
+                           fun validate_unexpected_error_/1,
+                           fun validate_expected_error_/1,
+                           fun validate_chained_/1,
+                           fun stacktrace_/1,
+                           fun stacktrace_function_clause_/1,
+                           fun change_func_/1,
+                           fun caller_does_not_crash_on_reload_/1,
+                           fun call_original_undef_/1,
+                           fun history_empty_/1,
+                           fun history_call_/1,
+                           fun history_throw_/1,
+                           fun history_throw_fun_/1,
+                           fun history_exit_/1,
+                           fun history_error_/1,
+                           fun history_error_args_/1,
+                           fun history_meck_throw_/1,
+                           fun history_meck_throw_fun_/1,
+                           fun history_meck_exit_/1,
+                           fun history_meck_error_/1,
+                           fun history_by_pid_/1,
+                           fun reset_/1,
+                           fun shortcut_expect_/1,
+                           fun shortcut_expect_negative_arity_/1,
+                           fun shortcut_call_return_value_/1,
+                           fun shortcut_call_argument_/1,
+                           fun shortcut_re_add_/1,
+                           fun shortcut_opaque_/1,
+                           fun shortcut_stacktrace_/1,
+                           fun delete_/1,
+                           fun expects_/1,
+                           fun called_false_no_args_/1,
+                           fun called_true_no_args_/1,
+                           fun called_true_two_functions_/1,
+                           fun called_false_one_arg_/1,
+                           fun called_true_one_arg_/1,
+                           fun called_false_few_args_/1,
+                           fun called_true_few_args_/1,
+                           fun called_few_args_matchers_/1,
+                           fun called_false_error_/1,
+                           fun called_true_error_/1,
+                           fun called_with_pid_no_args_/1,
+                           fun num_calls_/1,
+                           fun num_calls_error_/1,
+                           fun num_calls_with_pid_no_args_/1,
+                           fun called_wildcard_/1,
+                           fun sequence_/1,
+                           fun expect_args_sequence_/1,
+                           fun expect_arity_sequence_/1,
+                           fun expect_complex_sequence_/1,
+                           fun sequence_multi_/1,
+                           fun loop_/1,
+                           fun expect_empty_clause_list_/1,
+                           fun expect_args_value_/1,
+                           fun expect_args_invalid_call_/1,
+                           fun expect_arity_value_/1,
+                           fun expect_args_loop_/1,
+                           fun expect_arity_loop_/1,
+                           fun expect_complex_loop_/1,
+                           fun expect_loop_in_seq_/1,
+                           fun expect_args_exception_/1,
+                           fun expect_arity_exception_/1,
+                           fun expect_arity_clause_/1,
+                           fun loop_multi_/1,
+                           fun expect_args_pattern_override_/1,
+                           fun expect_args_pattern_shadow_/1,
+                           fun expect_args_pattern_missing_/1,
+                           fun expect_args_pattern_invalid_/1,
+                           fun expect_args_matchers_/1,
+                           fun expect_ret_specs_/1
+                          }.
+
+setup() ->
+    % Uncomment to run tests with dbg:
+    % dbg:tracer(),
+    % dbg:p(all, call),
+    % dbg:tpl(meck, ),
+    ok = meck:new(mymod, non_strict),
+    mymod.
+
+teardown(Module) ->
+    catch meck:unload(Module).
+
+%% --- Tests using setup and teardown -----------------------------------------
+
+new_(Mod) ->
+    Info = Mod:module_info(),
+    ?assert(is_list(Info)).
+
+unload_(Mod) ->
+    ok = meck:unload(Mod),
+    ?assertEqual(false, code:is_loaded(Mod)).
+
+double_new_(Mod) ->
+    ?assertError({already_started, _}, meck:new(Mod)).
+
+validate_(Mod) ->
+    ?assertEqual(true, meck:validate(Mod)).
+
+expect_(Mod) ->
+    ok = meck:expect(Mod, test, fun() -> ok end),
+    ?assertEqual(true, meck:validate(Mod)).
+
+exports_(Mod) ->
+    ok = meck:expect(Mod, test1, fun() -> ok end),
+    ok = meck:expect(Mod, test2, fun(_) -> ok end),
+    ok = meck:expect(Mod, test3, fun(_, _) -> ok end),
+    ?assertEqual(0, proplists:get_value(test1, Mod:module_info(exports))),
+    ?assertEqual(1, proplists:get_value(test2, Mod:module_info(exports))),
+    ?assertEqual(2, proplists:get_value(test3, Mod:module_info(exports))),
+    ?assertEqual(true, meck:validate(Mod)).
+
+call_return_value_(Mod) ->
+    ok = meck:expect(Mod, test, fun() -> apa end),
+    ?assertEqual(apa, Mod:test()),
+    ?assertEqual(true, meck:validate(Mod)).
+
+call_return_value_improper_list_(Mod) ->
+    Dict = dict:store(hest, apa, dict:new()),
+    ok = meck:expect(Mod, test, 0, Dict),
+    ?assertEqual(Dict, Mod:test()),
+    ?assertEqual(true, meck:validate(Mod)).
+
+call_argument_(Mod) ->
+    ok = meck:expect(Mod, test, fun(hest, 1) -> apa end),
+    ?assertEqual(apa, Mod:test(hest, 1)),
+    ?assertEqual(true, meck:validate(Mod)).
+
+call_function_clause_(Mod) ->
+    ok = meck:expect(Mod, test, fun(hest, 1) -> apa end),
+    ?assertError(function_clause, Mod:test(hest, 2)),
+    ?assertEqual(false, meck:validate(Mod)).
+
+validate_unexpected_error_(Mod) ->
+    ok = meck:expect(Mod, test, fun(hest, 1) -> erlang:error(timeout) end),
+    ?assertError(timeout, Mod:test(hest, 1)),
+    ?assertEqual(false, meck:validate(Mod)).
+
+validate_expected_error_(Mod) ->
+    ok = meck:expect(Mod, test, fun(hest, 1) ->
+                                     meck:exception(error, timeout)
+                             end),
+    ?assertError(timeout, Mod:test(hest, 1)),
+    ?assertEqual(true, meck:validate(Mod)).
+
+validate_chained_(Mod) ->
+    ok = meck:new(mymod2, non_strict),
+    ok = meck:expect(mymod2, test, fun() ->
+                                      meck:exception(error, test_error)
+                              end),
+    ok = meck:expect(Mod, test, fun() ->
+                                     mymod2:test()
+                             end),

osmo-s1gw_0.1.1.51.d6b3.tar.xz/build_dep.tar.gz -> osmo-s1gw_0.1.1.54.d545.tar.xz/build_dep.tar.gz Changed

osmo-s1gw_0.1.1.51.d6b3.tar.xz/config/sys.config -> osmo-s1gw_0.1.1.54.d545.tar.xz/config/sys.config Changed

osmo-s1gw_0.1.1.51.d6b3.tar.xz/contrib/generate_build_dep.sh -> osmo-s1gw_0.1.1.54.d545.tar.xz/contrib/generate_build_dep.sh Changed

osmo-s1gw_0.1.1.51.d6b3.tar.xz/debian/changelog -> osmo-s1gw_0.1.1.54.d545.tar.xz/debian/changelog Changed

osmo-s1gw_0.1.1.51.d6b3.tar.xz/rebar.config -> osmo-s1gw_0.1.1.54.d545.tar.xz/rebar.config Changed

osmo-s1gw_0.1.1.54.d545.tar.xz/src/erab_fsm.erl Added

@@ -0,0 +1,424 @@
+%% Copyright (C) 2024 by sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+%% Author: Vadim Yanitskiy <vyanitskiy@sysmocom.de>
+%%
+%% All Rights Reserved
+%%
+%% SPDX-License-Identifier: AGPL-3.0-or-later
+%%
+%% This program is free software; you can redistribute it and/or modify
+%% it under the terms of the GNU Affero General Public License as
+%% published by the Free Software Foundation; either version 3 of the
+%% License, or (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU Affero General Public License
+%% along with this program.  If not, see <https://www.gnu.org/licenses/>.
+%%
+%% Additional Permission under GNU AGPL version 3 section 7:
+%%
+%% If you modify this Program, or any covered work, by linking or
+%% combining it with runtime libraries of Erlang/OTP as released by
+%% Ericsson on https://www.erlang.org (or a modified version of these
+%% libraries), containing parts covered by the terms of the Erlang Public
+%% License (https://www.erlang.org/EPLICENSE), the licensors of this
+%% Program grant you additional permission to convey the resulting work
+%% without the need to license the runtime libraries of Erlang/OTP under
+%% the GNU Affero General Public License. Corresponding Source for a
+%% non-source form of such a combination shall include the source code
+%% for the parts of the runtime libraries of Erlang/OTP used as well as
+%% that of the covered work.
+
+-module(erab_fsm).
+-behaviour(gen_statem).
+
+-export(init/1,
+         callback_mode/0,
+         erab_wait_setup_req/3,
+         session_establish/3,
+         erab_wait_setup_rsp/3,
+         session_modify/3,
+         erab_setup/3,
+         session_delete/3,
+         erab_wait_release_rsp/3,
+         code_change/4,
+         terminate/3).
+-export(start_link/1,
+         erab_setup_req/2,
+         erab_setup_rsp/2,
+         erab_release_req/1,
+         erab_release_rsp/1,
+         shutdown/1).
+
+-include_lib("kernel/include/logger.hrl").
+-include_lib("pfcplib/include/pfcp_packet.hrl").
+
+
+-define(ERAB_T_WAIT_SETUP_RSP, 5_000).
+-define(ERAB_T_WAIT_RELEASE_RSP, 5_000).
+-define(ERAB_T_SESSION_ESTABLISH, 2_000).
+-define(ERAB_T_SESSION_MODIFY, 2_000).
+-define(ERAB_T_SESSION_DELETE, 2_000).
+
+-type teid() :: 0..16#ffffffff.
+
+-record(erab_state, {from :: undefined | gen_statem:from(), %% destination to use when replying
+                     teid_from_access :: undefined | teid(), %% TEID to be used in eNB -> UPF
+                     teid_to_access :: undefined | teid(), %% TEID to be used in UPF -> eNB
+                     teid_from_core :: undefined | teid(), %% TEID to be used in PGW -> UPF
+                     teid_to_core :: undefined | teid(), %% TEID to be used in UPF -> PGW
+                     seid_loc :: undefined | pfcp_peer:pfcp_seid(), %% local SEID, chosen by us
+                     seid_rem :: undefined | pfcp_peer:pfcp_seid()  %% remote SEID, chosen by the UPF
+                    }).
+
+-type erab_state() :: #erab_state{}.
+
+%% ------------------------------------------------------------------
+%% public API
+%% ------------------------------------------------------------------
+
+-spec start_link(term()) -> gen_statem:start_ret().
+start_link(UID) ->
+    gen_statem:start_link(?MODULE, UID, ).
+
+
+%% @doc Indicate reception of E-RAB setup request (from the eNB).
+%% @param Pid  PID of an erab_fsm.
+%% @param UID  *unique* E-RAB identifier.
+%% @param TEID  TEID chosen by the eNB.
+%% @returns TEID to be sent to the core;  an error otherwise.
+%% @end
+-spec erab_setup_req(pid(), teid()) -> {ok, teid()} |
+                                       {error, term()}.
+erab_setup_req(Pid, TEID) ->
+    gen_statem:call(Pid, {?FUNCTION_NAME, TEID}).
+
+
+%% @doc Indicate reception of E-RAB setup response (from the core).
+%% @param Pid  PID of an erab_fsm.
+%% @param TEID  TEID chosen by the core.
+%% @returns TEID to be sent to the eNB;  an error otherwise.
+%% @end
+-spec erab_setup_rsp(pid(), teid()) -> {ok, teid()} |
+                                       {error, term()}.
+erab_setup_rsp(Pid, TEID) ->
+    gen_statem:call(Pid, {?FUNCTION_NAME, TEID}).
+
+
+-spec erab_release_req(pid()) -> ok.
+erab_release_req(Pid) ->
+    gen_statem:call(Pid, ?FUNCTION_NAME).
+
+
+-spec erab_release_rsp(pid()) -> ok.
+erab_release_rsp(Pid) ->
+    gen_statem:cast(Pid, ?FUNCTION_NAME).
+
+
+-spec shutdown(pid()) -> ok.
+shutdown(Pid) ->
+    gen_statem:stop(Pid).
+
+
+%% ------------------------------------------------------------------
+%% gen_statem API
+%% ------------------------------------------------------------------
+
+init(UID) ->
+    set_logging_prefix(UID),
+    %% request a unieue SEID for this E-RAB FSM
+    {ok, SEID} = pfcp_peer:seid_alloc(),
+    {ok, erab_wait_setup_req,
+     #erab_state{seid_loc = SEID}}.
+
+
+callback_mode() ->
+    state_functions, state_enter.
+
+
+%% state WAIT_SETUP_REQ :: wait E-RAB SETUP Req from the Access
+erab_wait_setup_req(enter, ?FUNCTION_NAME, S) ->
+    ?LOG_DEBUG("State enter: ~p", ?FUNCTION_NAME),
+    {keep_state, S};
+
+erab_wait_setup_req({call, From},
+                    {erab_setup_req, TEID_FromAcc},
+                    #erab_state{} = S) ->
+    ?LOG_DEBUG("Rx E-RAB SETUP Req (Access TEID ~p)", TEID_FromAcc),
+    {next_state, session_establish,
+     S#erab_state{from = From,
+                  teid_from_access = TEID_FromAcc}};
+
+erab_wait_setup_req(Event, EventData, S) ->
+    ?LOG_ERROR("Unexpected event ~p: ~p", Event, EventData),
+    {keep_state, S}.
+
+
+%% state SESSION_ESTABLISH :: PFCP session establishment
+session_establish(enter, OldState, S) ->
+    ?LOG_DEBUG("State change: ~p -> ~p", OldState, ?FUNCTION_NAME),
+    ok = session_establish_req(S),
+    {next_state, ?FUNCTION_NAME, S, %% loop transition to enable state_timeout
+     {state_timeout, ?ERAB_T_SESSION_ESTABLISH, ?FUNCTION_NAME}};
+
+session_establish(state_timeout, _Timeout,
+                  #erab_state{from = From}) ->
+    ?LOG_ERROR("PFCP session establishment timeout"),
+    {stop_and_reply,
+     {shutdown, timeout},
+     {reply, From, {error, {timeout, ?FUNCTION_NAME}}}};
+
+session_establish(info, #pfcp{} = PDU,
+                  #erab_state{from = From,
+                              seid_loc = SEID_Rsp} = S) ->
+    case PDU of
+        #pfcp{type = session_establishment_response,
+              seid = SEID_Rsp, %% matches F-SEID we sent in the ESTABLISH Req
+              ie = #{pfcp_cause := 'Request accepted',
+                     f_seid := #f_seid{seid = F_SEID},
+                     created_pdr := #{f_teid := #f_teid{teid = TEID_ToCore}},
+                                     #{f_teid := #f_teid{teid = TEID_ToAcc}}}} ->
+            ?LOG_DEBUG("PFCP session established"),
+            {next_state, erab_wait_setup_rsp,
+             S#erab_state{from = undefined,
+                          seid_rem = F_SEID, %% SEID to be used in further requests from us
+                          teid_to_core = TEID_ToCore,
+                          teid_to_access = TEID_ToAcc},
+             {reply, From, {ok, TEID_ToCore}}};
+        _ ->
+            ?LOG_ERROR("Rx unexpected PFCP PDU: ~p", PDU),
+            {stop_and_reply,
+             {shutdown, unexp_pdu},
+             {reply, From, {error, {unexp_pdu, ?FUNCTION_NAME}}}}
+    end;
+
+session_establish(Event, EventData, S) ->
+    ?LOG_ERROR("Unexpected event ~p: ~p", Event, EventData),

osmo-s1gw_0.1.1.51.d6b3.tar.xz/src/osmo_s1gw.app.src -> osmo-s1gw_0.1.1.54.d545.tar.xz/src/osmo_s1gw.app.src Changed

osmo-s1gw_0.1.1.51.d6b3.tar.xz/src/osmo_s1gw_sup.erl -> osmo-s1gw_0.1.1.54.d545.tar.xz/src/osmo_s1gw_sup.erl Changed

@@ -47,6 +47,8 @@
 -define(ENV_DEFAULT_MME_LOC_ADDR, "127.0.2.1").
 -define(ENV_DEFAULT_MME_REM_ADDR, "127.0.2.10").
 -define(ENV_DEFAULT_MME_REM_PORT, ?S1AP_PORT).
+-define(ENV_DEFAULT_UPF_LOC_ADDR, "127.0.1.1").
+-define(ENV_DEFAULT_UPF_REM_ADDR, "127.0.1.2").
 
 %% ------------------------------------------------------------------
 %% supervisor API
@@ -62,6 +64,9 @@
     MmeLocAddr = get_env(mme_loc_addr, ?ENV_DEFAULT_MME_LOC_ADDR),
     MmeRemAddr = get_env(mme_rem_addr, ?ENV_DEFAULT_MME_REM_ADDR),
     MmeRemPort = get_env(mme_rem_port, ?ENV_DEFAULT_MME_REM_PORT),
+    UpfLocAddr = get_env(upf_loc_addr, ?ENV_DEFAULT_UPF_LOC_ADDR),
+    UpfRemAddr = get_env(upf_rem_addr, ?ENV_DEFAULT_UPF_REM_ADDR),
+
     SctpServer = {sctp_server, {sctp_server, start_link,
                                 S1GWBindAddr, S1GWBindPort,
                                  {{MmeLocAddr, MmeRemAddr}, MmeRemPort}},
@@ -69,7 +74,14 @@
                   5000,
                   worker,
                   sctp_server},
-    {ok, {{one_for_all, 5, 10}, SctpServer}}.
+    PfcpPeer = {pfcp_peer, {pfcp_peer, start_link,
+                            UpfLocAddr, UpfRemAddr},
+                permanent,
+                5000,
+                worker,
+                pfcp_peer},
+
+    {ok, {{one_for_one, 5, 10}, SctpServer, PfcpPeer}}.
 
 
 %% ------------------------------------------------------------------

osmo-s1gw_0.1.1.54.d545.tar.xz/src/pfcp_peer.erl Added

@@ -0,0 +1,398 @@
+%% Copyright (C) 2024 by sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+%% Author: Vadim Yanitskiy <vyanitskiy@sysmocom.de>
+%%
+%% All Rights Reserved
+%%
+%% SPDX-License-Identifier: AGPL-3.0-or-later
+%%
+%% This program is free software; you can redistribute it and/or modify
+%% it under the terms of the GNU Affero General Public License as
+%% published by the Free Software Foundation; either version 3 of the
+%% License, or (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU Affero General Public License
+%% along with this program.  If not, see <https://www.gnu.org/licenses/>.
+%%
+%% Additional Permission under GNU AGPL version 3 section 7:
+%%
+%% If you modify this Program, or any covered work, by linking or
+%% combining it with runtime libraries of Erlang/OTP as released by
+%% Ericsson on https://www.erlang.org (or a modified version of these
+%% libraries), containing parts covered by the terms of the Erlang Public
+%% License (https://www.erlang.org/EPLICENSE), the licensors of this
+%% Program grant you additional permission to convey the resulting work
+%% without the need to license the runtime libraries of Erlang/OTP under
+%% the GNU Affero General Public License. Corresponding Source for a
+%% non-source form of such a combination shall include the source code
+%% for the parts of the runtime libraries of Erlang/OTP used as well as
+%% that of the covered work.
+
+-module(pfcp_peer).
+-behaviour(gen_statem).
+
+-export(init/1,
+         callback_mode/0,
+         connecting/3,
+         connected/3,
+         code_change/4,
+         terminate/3).
+-export(start_link/2,
+         seid_alloc/0,
+         session_establish_req/3,
+         session_modify_req/3,
+         session_delete_req/1,
+         shutdown/0).
+
+-include_lib("kernel/include/logger.hrl").
+-include_lib("pfcplib/include/pfcp_packet.hrl").
+
+%% 3GPP TS 29.244, section 4.2 "UDP Header and Port Numbers"
+-define(PFCP_PORT, 8805).
+
+-type pfcp_session_rsp() :: ok | {error, term()}.
+
+-type pfcp_msg_type() :: atom().
+-type pfcp_seq_nr() :: 0..16#ffffff.
+-type pfcp_seid() :: 0..16#ffffffffffffffff.
+-type pfcp_f_seid() :: #f_seid{}.
+-type pfcp_ies() :: term() | map() | binary().
+-type pfcp_msg() :: {pfcp_msg_type(), pfcp_ies()}.
+-type pfcp_pdu() :: #pfcp{}.
+
+-export_type(pfcp_session_rsp/0,
+              pfcp_msg_type/0,
+              pfcp_seq_nr/0,
+              pfcp_seid/0,
+              pfcp_ies/0,
+              pfcp_msg/0,
+              pfcp_pdu/0).
+
+-record(peer_state, {seid :: pfcp_seid(),
+                     sock :: gen_udp:socket(),
+                     loc_addr :: inet:ip_address(),
+                     rem_addr :: inet:ip_address(),
+                     seq_nr :: pfcp_seq_nr(),
+                     registry :: dict:dict()
+                    }).
+
+-type peer_state() :: #peer_state{}.
+
+%% ------------------------------------------------------------------
+%% public API
+%% ------------------------------------------------------------------
+
+start_link(LocAddr, RemAddr) ->
+    gen_statem:start_link({local, ?MODULE}, ?MODULE,
+                          LocAddr, RemAddr,
+                          ).
+
+
+%% Request to allocate a unique SEID
+-spec seid_alloc() -> {ok, pfcp_seid()} |
+                      {error, term()}.
+seid_alloc() ->
+    gen_statem:call(?MODULE, ?FUNCTION_NAME).
+
+
+-spec session_establish_req(pfcp_seid(), list(), list()) -> pfcp_session_rsp().
+session_establish_req(SEID, PDRs, FARs) ->
+    gen_statem:call(?MODULE, {?FUNCTION_NAME, SEID, PDRs, FARs}).
+
+
+-spec session_modify_req(pfcp_seid(), list(), list()) -> pfcp_session_rsp().
+session_modify_req(SEID, PDRs, FARs) ->
+    gen_statem:call(?MODULE, {?FUNCTION_NAME, SEID, PDRs, FARs}).
+
+
+-spec session_delete_req(pfcp_seid()) -> pfcp_session_rsp().
+session_delete_req(SEID) ->
+    gen_statem:call(?MODULE, {?FUNCTION_NAME, SEID}).
+
+
+shutdown() ->
+    gen_statem:stop(?MODULE).
+
+
+%% ------------------------------------------------------------------
+%% gen_server API
+%% ------------------------------------------------------------------
+
+init(LocAddrStr, RemAddr) when is_list(LocAddrStr) ->
+    {ok, LocAddr} = inet:parse_address(LocAddrStr),
+    init(LocAddr, RemAddr);
+
+init(LocAddr, RemAddrStr) when is_list(RemAddrStr) ->
+    {ok, RemAddr} = inet:parse_address(RemAddrStr),
+    init(LocAddr, RemAddr);
+
+init(LocAddr, RemAddr) ->
+    process_flag(trap_exit, true),
+    {ok, Sock} = gen_udp:open(?PFCP_PORT, binary,
+                                           {ip, LocAddr},
+                                           {reuseaddr, true},
+                                           {active, true}),
+    ?LOG_INFO("PFCP peer @ ~p will talk to UPF @ ~p", LocAddr, RemAddr),
+    {ok, connecting, #peer_state{seid = 0,
+                                 sock = Sock,
+                                 loc_addr = LocAddr,
+                                 rem_addr = RemAddr,
+                                 seq_nr = 0,
+                                 registry = dict:new()}}.
+
+
+callback_mode() ->
+    state_functions, state_enter.
+
+
+%% CONNECTING state
+connecting(enter, OldState,
+           #peer_state{} = S0) ->
+    ?LOG_INFO("State change: ~p -> ~p", OldState, ?FUNCTION_NAME),
+    %% Tx PFCP Association Setup
+    {ok, S1} = send_assoc_setup(S0),
+    {next_state, connecting, S1,
+     {state_timeout, 2_000, assoc_setup_timeout}};
+
+%% Handle Association Setup timeout
+connecting(state_timeout, assoc_setup_timeout, _S) ->
+    {stop, {shutdown, assoc_setup_timeout}};
+
+%% Handle incoming PFCP PDU(s)
+connecting(info, {udp, Sock, _FromIp, _FromPort, Data},
+           #peer_state{sock = Sock} = S) ->
+    case decode_pdu(Data, S) of
+        #pfcp{type = association_setup_response,
+              ie = #{pfcp_cause := 'Request accepted'}} ->
+            ?LOG_INFO("Rx Association Setup Response (Request accepted)"),
+            {next_state, connected, S};
+        #pfcp{type = association_setup_response,
+              ie = #{pfcp_cause := Cause}} ->
+            ?LOG_ERROR("Rx Association Setup Response (~p)", Cause),
+            {stop, {shutdown, assoc_setup_nack}};
+        PDU ->
+            ?LOG_NOTICE("Rx unexpected PFCP PDU: ~p", PDU),
+            {keep_state, S}
+    end;
+
+connecting(Event, EventData, S) ->
+    handle_event(?FUNCTION_NAME, Event, EventData, S).
+
+
+%% CONNECTED state
+connected(enter, OldState, S) ->
+    ?LOG_INFO("State change: ~p -> ~p", OldState, ?FUNCTION_NAME),
+    {keep_state, S};
+
+connected({call, From},
+          {session_establish_req, SEID, PDRs, FARs},
+          #peer_state{} = S0) ->
+    {Result, S1} = send_session_establish_req(SEID, PDRs, FARs, S0),
+    {keep_state, S1, {reply, From, Result}};
+
+connected({call, From},
+          {session_modify_req, SEID, PDRs, FARs},
+          #peer_state{} = S0) ->

osmo-s1gw_0.1.1.51.d6b3.tar.xz/src/s1ap_proxy.erl -> osmo-s1gw_0.1.1.54.d545.tar.xz/src/s1ap_proxy.erl Changed

@@ -34,7 +34,9 @@
 
 -module(s1ap_proxy).
 
--export(handle_pdu/1,
+-export(init/0,
+         deinit/1,
+         handle_pdu/2,
          encode_pdu/1,
          decode_pdu/1).
 
@@ -45,20 +47,37 @@
 -include("S1AP-Containers.hrl").
 -include("S1AP-Constants.hrl").
 
+
+-record(proxy_state, { }).
+
+-type proxy_state() :: #proxy_state{}.
+
 %% ------------------------------------------------------------------
 %% public API
 %% ------------------------------------------------------------------
 
+%% Initialize per-connection data
+-spec init() -> proxy_state().
+init() ->
+    #proxy_state{}.
+
+
+%% De-initialize per-connection data
+-spec deinit(proxy_state()) -> ok.
+deinit(_S) ->
+    ok.
+
+
 %% Process an S1AP PDU
--spec handle_pdu(binary()) -> binary().
-handle_pdu(Data) when is_binary(Data) ->
+-spec handle_pdu(binary(), proxy_state()) -> {binary(), proxy_state()}.
+handle_pdu(Data, S) when is_binary(Data) ->
     case decode_pdu(Data) of
         {ok, Pdu} ->
             ?LOG_INFO("S1AP PDU: ~p", Pdu),
-            handle_pdu(Data, Pdu);
+            handle_pdu(Data, Pdu, S);
         {error, {asn1, Error}} ->
             ?LOG_ERROR("S1AP PDU decoding failed: ~p", Error),
-            Data
+            {Data, S}
     end.
 
 
@@ -80,73 +99,73 @@
     'S1AP-PDU-Descriptions':decode('S1AP-PDU', Data).
 
 
-%% Helper function for handle_pdu/2.
+%% Helper function for handle_pdu/3.
 %% Attempt to encode a new (modified) S1AP PDU,
 %% return a new binary() on success or Data on error.
-handle_pdu_new(Data, NewPdu) ->
+handle_pdu_new(Data, NewPdu, S) ->
     case encode_pdu(NewPdu) of
         {ok, NewData} ->
-            NewData;
+            {NewData, S};
         {error, {asn1, Error}} ->
             ?LOG_ERROR("S1AP PDU encoding failed: ~p", Error),
-            Data
+            {Data, S}
     end.
 
 
 %% 9.1.3.1 E-RAB SETUP REQUEST
 handle_pdu(Data, {Outcome = initiatingMessage,
                   #'InitiatingMessage'{procedureCode = ?'id-E-RABSetup',
-                                       value = Content} = Pdu}) ->
+                                       value = Content} = Pdu}, S0) ->
     ?LOG_DEBUG("Patching E-RAB SETUP REQUEST"),
-    IEs = handle_ies(Content#'E-RABSetupRequest'.protocolIEs,
-                     ?'id-E-RABToBeSetupListBearerSUReq'),
+    {IEs, S1} = handle_ies(Content#'E-RABSetupRequest'.protocolIEs,
+                           ?'id-E-RABToBeSetupListBearerSUReq', S0),
     NewContent = Content#'E-RABSetupRequest'{protocolIEs = IEs},
-    handle_pdu_new(Data, {Outcome, Pdu#'InitiatingMessage'{value = NewContent}});
+    handle_pdu_new(Data, {Outcome, Pdu#'InitiatingMessage'{value = NewContent}}, S1);
 
 %% 9.1.3.2 E-RAB SETUP RESPONSE
 handle_pdu(Data, {Outcome = successfulOutcome,
                   #'SuccessfulOutcome'{procedureCode = ?'id-E-RABSetup',
-                                       value = Content} = Pdu}) ->
+                                       value = Content} = Pdu}, S0) ->
     ?LOG_DEBUG("Patching E-RAB SETUP RESPONSE"),
-    IEs = handle_ies(Content#'E-RABSetupResponse'.protocolIEs,
-                     ?'id-E-RABSetupListBearerSURes'),
+    {IEs, S1} = handle_ies(Content#'E-RABSetupResponse'.protocolIEs,
+                           ?'id-E-RABSetupListBearerSURes', S0),
     NewContent = Content#'E-RABSetupResponse'{protocolIEs = IEs},
-    handle_pdu_new(Data, {Outcome, Pdu#'SuccessfulOutcome'{value = NewContent}});
+    handle_pdu_new(Data, {Outcome, Pdu#'SuccessfulOutcome'{value = NewContent}}, S1);
 
 %% TODO: 9.1.3.3 E-RAB MODIFY REQUEST / (Optional) Transport Information
 
 %% 9.1.3.8 E-RAB MODIFICATION INDICATION
 handle_pdu(Data, {Outcome = initiatingMessage,
                   #'InitiatingMessage'{procedureCode = ?'id-E-RABModificationIndication',
-                                       value = Content} = Pdu}) ->
+                                       value = Content} = Pdu}, S0) ->
     ?LOG_DEBUG("Patching E-RAB MODIFICATION INDICATION"),
     IEs = Content#'E-RABModificationIndication'.protocolIEs,
     %% E-RAB to be Modified List
-    IEs1 = handle_ies(IEs, ?'id-E-RABToBeModifiedListBearerModInd'),
+    {IEs1, S1} = handle_ies(IEs, ?'id-E-RABToBeModifiedListBearerModInd', S0),
     %% E-RAB not to be Modified List
-    IEs2 = handle_ies(IEs1, ?'id-E-RABNotToBeModifiedListBearerModInd'),
+    {IEs2, S2} = handle_ies(IEs1, ?'id-E-RABNotToBeModifiedListBearerModInd', S1),
     NewContent = Content#'E-RABModificationIndication'{protocolIEs = IEs2},
-    handle_pdu_new(Data, {Outcome, Pdu#'InitiatingMessage'{value = NewContent}});
+    handle_pdu_new(Data, {Outcome, Pdu#'InitiatingMessage'{value = NewContent}}, S2);
 
 %% 9.1.4.1 INITIAL CONTEXT SETUP REQUEST
 handle_pdu(Data, {Outcome = initiatingMessage,
                   #'InitiatingMessage'{procedureCode = ?'id-InitialContextSetup',
-                                       value = Content} = Pdu}) ->
+                                       value = Content} = Pdu}, S0) ->
     ?LOG_DEBUG("Patching INITIAL CONTEXT SETUP REQUEST"),
-    IEs = handle_ies(Content#'InitialContextSetupRequest'.protocolIEs,
-                     ?'id-E-RABToBeSetupListCtxtSUReq'),
+    {IEs, S1} = handle_ies(Content#'InitialContextSetupRequest'.protocolIEs,
+                           ?'id-E-RABToBeSetupListCtxtSUReq', S0),
     NewContent = Content#'InitialContextSetupRequest'{protocolIEs = IEs},
-    handle_pdu_new(Data, {Outcome, Pdu#'InitiatingMessage'{value = NewContent}});
+    handle_pdu_new(Data, {Outcome, Pdu#'InitiatingMessage'{value = NewContent}}, S1);
 
 %% 9.1.4.3 INITIAL CONTEXT SETUP RESPONSE
 handle_pdu(Data, {Outcome = successfulOutcome,
                   #'SuccessfulOutcome'{procedureCode = ?'id-InitialContextSetup',
-                                       value = Content} = Pdu}) ->
+                                       value = Content} = Pdu}, S0) ->
     ?LOG_DEBUG("Patching INITIAL CONTEXT SETUP RESPONSE"),
-    IEs = handle_ies(Content#'InitialContextSetupResponse'.protocolIEs,
-                     ?'id-E-RABSetupListCtxtSURes'),
+    {IEs, S1} = handle_ies(Content#'InitialContextSetupResponse'.protocolIEs,
+                           ?'id-E-RABSetupListCtxtSURes', S0),
     NewContent = Content#'InitialContextSetupResponse'{protocolIEs = IEs},
-    handle_pdu_new(Data, {Outcome, Pdu#'SuccessfulOutcome'{value = NewContent}});
+    handle_pdu_new(Data, {Outcome, Pdu#'SuccessfulOutcome'{value = NewContent}}, S1);
 
 %% TODO: 9.1.5.2 HANDOVER COMMAND :: (O) UL/DL Transport Layer Address
 %% TODO: 9.1.5.4 HANDOVER REQUEST :: (M) Transport Layer Address
@@ -156,107 +175,108 @@
 %% TODO: 9.1.5.9 PATH SWITCH REQUEST ACKNOWLEDGE :: (M) Transport Layer Address
 
 %% Proxy all other messages unmodified
-handle_pdu(Data, _Pdu) ->
-    Data.
+handle_pdu(Data, _Pdu, S) ->
+    {Data, S}.
 
 
 %% Handle a single IE (Information Element)
--spec handle_ie(tuple()) -> tuple().
+-spec handle_ie(tuple(), proxy_state()) -> {tuple(), proxy_state()}.
 
 %% E-RAB SETUP REQUEST related IEs
 handle_ie(#'ProtocolIE-Field'{id = ?'id-E-RABToBeSetupListBearerSUReq',
-                              value = Content}) ->
+                              value = Content}, S) ->
     %% This IE contains a list of BearerSUReq, so patch inner IEs
-    handle_ies(Content, ?'id-E-RABToBeSetupItemBearerSUReq');
+    handle_ies(Content, ?'id-E-RABToBeSetupItemBearerSUReq', S);
 
 handle_ie(#'ProtocolIE-Field'{id = ?'id-E-RABToBeSetupItemBearerSUReq',
-                              value = Content}) ->
+                              value = Content}, S) ->
     %% eNB -> MME direction: we pass our MME facing local address
     TLA = transp_layer_addr(mme_loc_addr),
-    Content#'E-RABToBeSetupItemBearerSUReq'{transportLayerAddress = TLA};
+    {Content#'E-RABToBeSetupItemBearerSUReq'{transportLayerAddress = TLA}, S};
 
 %% E-RAB SETUP RESPONSE related IEs
 handle_ie(#'ProtocolIE-Field'{id = ?'id-E-RABSetupListBearerSURes',
-                              value = Content}) ->
+                              value = Content}, S) ->
     %% This IE contains a list of BearerSURes, so patch inner IEs
-    handle_ies(Content, ?'id-E-RABSetupItemBearerSURes');
+    handle_ies(Content, ?'id-E-RABSetupItemBearerSURes', S);
 
 handle_ie(#'ProtocolIE-Field'{id = ?'id-E-RABSetupItemBearerSURes',
-                              value = Content}) ->
+                              value = Content}, S) ->
     %% MME -> eNB direction: we pass our eNB facing local address
     TLA = transp_layer_addr(s1gw_bind_addr),
-    Content#'E-RABSetupItemBearerSURes'{transportLayerAddress = TLA};
+    {Content#'E-RABSetupItemBearerSURes'{transportLayerAddress = TLA}, S};
 
 %% E-RAB MODIFICATION INDICATION related IEs
 handle_ie(#'ProtocolIE-Field'{id = ?'id-E-RABToBeModifiedListBearerModInd',
-                              value = Content}) ->

osmo-s1gw_0.1.1.51.d6b3.tar.xz/src/sctp_proxy.erl -> osmo-s1gw_0.1.1.54.d545.tar.xz/src/sctp_proxy.erl Changed

@@ -79,7 +79,8 @@
      #{enb_aid => Aid,
        mme_addr => MmeAddr,
        mme_port => MmePort,
-       tx_queue => }}.
+       tx_queue => ,
+       priv => s1ap_proxy:init()}}.
 
 
 callback_mode() ->
@@ -131,16 +132,16 @@
 
 
 %% CONNECTED state
-connected(enter, OldState, S) ->
+connected(enter, OldState, S0) ->
     ?LOG_INFO("State change: ~p -> ~p", OldState, ?FUNCTION_NAME),
     %% Send pending eNB -> MME messages (if any)
-    ok = sctp_send_pending(S),
-    {keep_state, maps:remove(tx_queue, S)};
+    S1 = sctp_send_pending(S0),
+    {keep_state, S1};
 
 %% Handle an eNB -> MME data forwarding request (forward)
-connected(cast, {send_data, Data}, S) ->
-    ok = sctp_send(S, Data),
-    {keep_state, S};
+connected(cast, {send_data, Data}, S0) ->
+    S1 = sctp_send(Data, S0),
+    {keep_state, S1};
 
 %% Handle an #sctp_assoc_change event (MME connection state)
 connected(info, {sctp, _Socket, MmeAddr, MmePort,
@@ -158,11 +159,13 @@
 
 %% Handle an #sctp_sndrcvinfo event (MME -> eNB data)
 connected(info, {sctp, _Socket, MmeAddr, MmePort,
-                 {#sctp_sndrcvinfo{assoc_id = Aid}, Data}}, S) ->
+                 {#sctp_sndrcvinfo{assoc_id = Aid}, Data}},
+          #{enb_aid := EnbAid, priv := Priv} = S) ->
     ?LOG_DEBUG("MME connection (id=~p, ~p:~p) -> eNB: ~p",
                Aid, MmeAddr, MmePort, Data),
-    sctp_server:send_data(maps:get(enb_aid, S), handle_pdu(Data)),
-    {keep_state, S};
+    {NewData, NewPriv} = handle_pdu(Data, Priv),
+    sctp_server:send_data(EnbAid, NewData),
+    {keep_state, S#{priv := NewPriv}};
 
 %% Catch-all for other kinds of SCTP events
 connected(info, {sctp, _Socket, MmeAddr, MmePort,
@@ -185,7 +188,10 @@
 terminate(Reason, State, S) ->
     ?LOG_NOTICE("Terminating in state ~p, reason ~p", State, Reason),
     case S of
-        #{sock := Sock, mme_aid := Aid} ->
+        #{sock := Sock,
+          mme_aid := Aid,
+          priv := Priv} ->
+            s1ap_proxy:deinit(Priv),
             sctp_client:disconnect({Sock, Aid}),
             gen_sctp:close(Sock);
         #{sock := Sock} ->
@@ -199,31 +205,36 @@
 %% ------------------------------------------------------------------
 
 %% A safe wrapper for s1ap_proxy:handle_pdu/1
--spec handle_pdu(binary()) -> binary().
-handle_pdu(Data) when is_binary(Data) ->
-    try s1ap_proxy:handle_pdu(Data) of
-        NewData -> NewData
+-spec handle_pdu(binary(), term()) -> {binary(), term()}.
+handle_pdu(Data, Priv) when is_binary(Data) ->
+    try s1ap_proxy:handle_pdu(Data, Priv) of
+        Result -> Result %% {NewData, NewPriv}
     catch
         Exception:Reason:StackTrace ->
             ?LOG_ERROR("An exception occurred: ~p, ~p, ~p", Exception, Reason, StackTrace),
-            Data %% proxy as-is
+            {Data, Priv} %% proxy as-is
     end.
 
 
 %% Send a single message to the MME
-sctp_send(#{sock := Sock, mme_aid := Aid}, Data) ->
-    sctp_client:send_data({Sock, Aid}, handle_pdu(Data)).
+sctp_send(Data,
+          #{sock := Sock,
+            mme_aid := Aid,
+            priv := Priv} = S) ->
+    {NewData, NewPriv} = handle_pdu(Data, Priv),
+    ok = sctp_client:send_data({Sock, Aid}, NewData),
+    S#{priv := NewPriv}.
 
 
 %% Send pending messages to the MME
 sctp_send_pending(#{tx_queue := Pending} = S) ->
-    sctp_send_pending(S, lists:reverse(Pending)).
+    sctp_send_pending(lists:reverse(Pending), S).
 
-sctp_send_pending(S, Data | Pending) ->
-    sctp_send(S, Data),
-    sctp_send_pending(S, Pending);
+sctp_send_pending(Data | Pending, S0) ->
+    S1 = sctp_send(Data, S0),
+    sctp_send_pending(Pending, S1);
 
-sctp_send_pending(_S, ) ->
-    ok.
+sctp_send_pending(, S) ->
+    S#{tx_queue := }.
 
 %% vim:set ts=4 sw=4 et:

osmo-s1gw_0.1.1.54.d545.tar.xz/test/erab_fsm_test.erl Added

@@ -0,0 +1,122 @@
+-module(erab_fsm_test).
+
+-include_lib("eunit/include/eunit.hrl").
+-include("pfcp_mock.hrl").
+
+%% ------------------------------------------------------------------
+%% setup functions
+%% ------------------------------------------------------------------
+
+-define(TC(Fun), {setup,
+                  fun start/0,
+                  fun stop/1,
+                  Fun}).
+
+
+start() ->
+    %% mock the PFCP peer API
+    pfcp_mock:mock_all(),
+    %% start an E-RAB FSM
+    {ok, Pid} = erab_fsm:start_link(?MODULE),
+    Pid.
+
+
+stop(_Pid) ->
+    pfcp_mock:unmock_all().
+
+
+%% ------------------------------------------------------------------
+%% testcase descriptions
+%% ------------------------------------------------------------------
+
+erab_setup_test_() ->
+    {"E-RAB setup :: success",
+      ?TC(fun test_erab_setup_success/1)},
+     {"E-RAB setup :: PFCP session establishment error",
+      ?TC(fun test_erab_setup_pfcp_establish_error/1)},
+     {"E-RAB setup :: PFCP session modification error",
+      ?TC(fun test_erab_setup_pfcp_modify_error/1)}.
+
+
+erab_release_test_() ->
+    {"E-RAB release :: success",
+      ?TC(fun test_erab_release_success/1)},
+     {"E-RAB release :: PFCP session deletion error",
+      ?TC(fun test_erab_release_pfcp_delete_error/1)}.
+
+
+erab_shutdown_test_() ->
+    {"E-RAB shutdown (no session)",
+      ?TC(fun test_erab_shutdown_no_session/1)},
+     {"E-RAB shutdown (expect session deletion)",
+      ?TC(fun test_erab_shutdown_session_del/1)}.
+
+
+%% ------------------------------------------------------------------
+%% actual testcases
+%% ------------------------------------------------------------------
+
+test_erab_setup_success(Pid) ->
+    ?_assertEqual({ok, ?TEID_ToCore}, erab_fsm:erab_setup_req(Pid, ?TEID_FromAcc)),
+     ?_assertEqual({ok, ?TEID_ToAcc}, erab_fsm:erab_setup_rsp(Pid, ?TEID_FromCore)),
+     ?_assertEqual(ok, erab_fsm:shutdown(Pid)),
+     ?_assertNot(erlang:is_process_alive(Pid)).
+
+
+test_erab_setup_pfcp_establish_error(Pid) ->
+    %% pfcp_peer:session_delete_req/1 shall not be called
+    ok = pfcp_mock:unmock_req(session_delete_req, 1),
+    %% pfcp_peer:session_establish_req/3 responds with a reject
+    PDU = pfcp_mock:pdu_rsp_reject(session_establishment_response, ?SEID_Loc),
+    pfcp_mock:mock_req(session_establish_req, PDU),
+    unlink(Pid), %% we expect the FSM to terminate abnormally
+    Error = {unexp_pdu, session_establish},
+    ?_assertEqual({error, Error}, erab_fsm:erab_setup_req(Pid, ?TEID_FromAcc)),
+     ?_assertNot(erlang:is_process_alive(Pid)).
+
+
+test_erab_setup_pfcp_modify_error(Pid) ->
+    %% pfcp_peer:session_modify_req/3 responds with a reject
+    PDU = pfcp_mock:pdu_rsp_reject(session_modification_response, ?SEID_Loc),
+    pfcp_mock:mock_req(session_modify_req, PDU),
+    unlink(Pid), %% we expect the FSM to terminate abnormally
+    Error = {unexp_pdu, session_modify},
+    ?_assertEqual({ok, ?TEID_ToCore}, erab_fsm:erab_setup_req(Pid, ?TEID_FromAcc)),
+     ?_assertEqual({error, Error}, erab_fsm:erab_setup_rsp(Pid, ?TEID_FromCore)),
+     ?_assertNot(erlang:is_process_alive(Pid)).
+
+
+test_erab_release_success(Pid) ->
+    ?_assertEqual({ok, ?TEID_ToCore}, erab_fsm:erab_setup_req(Pid, ?TEID_FromAcc)),
+     ?_assertEqual({ok, ?TEID_ToAcc}, erab_fsm:erab_setup_rsp(Pid, ?TEID_FromCore)),
+     ?_assertEqual(ok, erab_fsm:erab_release_req(Pid)),
+     ?_assertEqual(ok, erab_fsm:erab_release_rsp(Pid)),
+     ?_assertNot(erlang:is_process_alive(Pid)).
+
+
+test_erab_release_pfcp_delete_error(Pid) ->
+    %% pfcp_peer:session_delete_req/1 responds with a reject
+    PDU = pfcp_mock:pdu_rsp_reject(session_deletion_response, ?SEID_Loc),
+    pfcp_mock:mock_req(session_delete_req, PDU),
+    unlink(Pid), %% we expect the FSM to terminate abnormally
+    Error = {unexp_pdu, session_delete},
+    ?_assertEqual({ok, ?TEID_ToCore}, erab_fsm:erab_setup_req(Pid, ?TEID_FromAcc)),
+     ?_assertEqual({ok, ?TEID_ToAcc}, erab_fsm:erab_setup_rsp(Pid, ?TEID_FromCore)),
+     ?_assertEqual({error, Error}, erab_fsm:erab_release_req(Pid)),
+     ?_assertNot(erlang:is_process_alive(Pid)).
+
+
+test_erab_shutdown_no_session(Pid) ->
+    %% pfcp_peer:session_delete_req/1 shall not be called
+    ok = pfcp_mock:unmock_req(session_delete_req, 1),
+    ?_assertEqual(ok, erab_fsm:shutdown(Pid)),
+     ?_assertNot(erlang:is_process_alive(Pid)).
+
+
+test_erab_shutdown_session_del(Pid) ->
+    ?_assertEqual({ok, ?TEID_ToCore}, erab_fsm:erab_setup_req(Pid, ?TEID_FromAcc)),
+     ?_assertEqual({ok, ?TEID_ToAcc}, erab_fsm:erab_setup_rsp(Pid, ?TEID_FromCore)),
+     ?_assertEqual(ok, erab_fsm:shutdown(Pid)),
+     ?_assertNot(erlang:is_process_alive(Pid)).
+
+%% vim:set ts=4 sw=4 et:

osmo-s1gw_0.1.1.54.d545.tar.xz/test/pfcp_mock.erl Added

@@ -0,0 +1,104 @@
+-module(pfcp_mock).
+
+-export(mock_all/0,
+         mock_req/2,
+         unmock_all/0,
+         unmock_req/2).
+-export(pdu_rsp/3,
+         pdu_rsp_accept/2,
+         pdu_rsp_reject/2,
+         pdu_session_establish_rsp/0,
+         pdu_session_modify_rsp/0,
+         pdu_session_delete_rsp/0).
+
+-include_lib("stdlib/include/assert.hrl").
+-include_lib("pfcplib/include/pfcp_packet.hrl").
+-include("pfcp_mock.hrl").
+
+%% ------------------------------------------------------------------
+%% public API
+%% ------------------------------------------------------------------
+
+%% mock all pfcp_peer module functions
+mock_all() ->
+    meck:new(pfcp_peer),
+    meck:expect(pfcp_peer, seid_alloc, fun() -> {ok, ?SEID_Loc} end),
+    mock_req(session_establish_req, pdu_session_establish_rsp()),
+    mock_req(session_modify_req, pdu_session_modify_rsp()),
+    mock_req(session_delete_req, pdu_session_delete_rsp()).
+
+
+%% unmock all pfcp_peer module functions
+unmock_all() ->
+    true = meck:validate(pfcp_peer),
+    meck:unload(pfcp_peer).
+
+
+pfcp_req_stub(Rsp) ->
+    %% this code is executed by E-RAB FSM itself,
+    %% thus self() evaluates to its own Pid
+    self() ! Rsp,
+    ok.
+
+
+%% mock one of the pfcp_peer:*_req functions
+mock_req(session_establish_req = Fun, Rsp) ->
+    FunBody = fun(F_SEID, _PDRs, _FARs) ->
+        %% expect the E-RAB FSM to pass its local SEID as F-SEID
+        ?assertEqual(F_SEID, ?SEID_Loc),
+        pfcp_req_stub(Rsp)
+    end,
+    meck:expect(pfcp_peer, Fun, FunBody);
+
+mock_req(session_modify_req = Fun, Rsp) ->
+    FunBody = fun(SEID, _PDRs, _FARs) ->
+        %% expect the E-RAB FSM to pass the remote SEID
+        ?assertEqual(SEID, ?SEID_Rem),
+        pfcp_req_stub(Rsp)
+    end,
+    meck:expect(pfcp_peer, Fun, FunBody);
+
+mock_req(session_delete_req = Fun, Rsp) ->
+    FunBody = fun(SEID) ->
+        %% expect the E-RAB FSM to pass the remote SEID
+        ?assertEqual(SEID, ?SEID_Rem),
+        pfcp_req_stub(Rsp)
+    end,
+    meck:expect(pfcp_peer, Fun, FunBody).
+
+
+%% unmock one of the pfcp_peer:*_req functions
+unmock_req(Fun, Arity) ->
+    meck:delete(pfcp_peer, Fun, Arity).
+
+
+%% ------------------------------------------------------------------
+%% PFCP PDU templates
+%% ------------------------------------------------------------------
+
+pdu_rsp(MsgType, SEID, IEs) ->
+    #pfcp{type = MsgType, seid = SEID, ie = IEs}.
+
+pdu_rsp_accept(MsgType, SEID) ->
+    pdu_rsp(MsgType, SEID, #{pfcp_cause => 'Request accepted'}).
+
+pdu_rsp_reject(MsgType, SEID) ->
+    pdu_rsp(MsgType, SEID, #{pfcp_cause => 'Request rejected'}).
+
+
+pdu_session_establish_rsp() ->
+    IEs = #{pfcp_cause => 'Request accepted',
+            f_seid => #f_seid{seid = ?SEID_Rem},
+            created_pdr => #{f_teid => #f_teid{teid = ?TEID_ToCore}},
+                            #{f_teid => #f_teid{teid = ?TEID_ToAcc}}},
+    pdu_rsp(session_establishment_response, ?SEID_Loc, IEs).
+
+
+pdu_session_modify_rsp() ->
+    pdu_rsp_accept(session_modification_response, ?SEID_Loc).
+
+
+pdu_session_delete_rsp() ->
+    pdu_rsp_accept(session_deletion_response, ?SEID_Loc).
+
+%% vim:set ts=4 sw=4 et:

osmo-s1gw_0.1.1.54.d545.tar.xz/test/pfcp_mock.hrl Added

osmo-s1gw_0.1.1.51.d6b3.tar.xz/test/s1ap_proxy_test.erl -> osmo-s1gw_0.1.1.54.d545.tar.xz/test/s1ap_proxy_test.erl Changed

@@ -6,7 +6,44 @@
 -define(EXP_ADDR_BIN, << 16#7f, 16#00, 16#00, 16#01 >>).
 
 %% ------------------------------------------------------------------
-%% testcases
+%% setup functions
+%% ------------------------------------------------------------------
+
+-define(TC(Fun), {setup,
+                  fun start/0,
+                  fun stop/1,
+                  Fun}).
+
+
+start() ->
+    s1ap_proxy:init().
+
+
+stop(S) ->
+    s1ap_proxy:deinit(S).
+
+
+%% ------------------------------------------------------------------
+%% testcase descriptions
+%% ------------------------------------------------------------------
+
+s1ap_proxy_test_() ->
+    {"S1 SETUP REQUEST (unmodified)",
+      ?TC(fun test_s1_setup_req/1)},
+     {"E-RAB SETUP REQUEST",
+      ?TC(fun test_e_rab_setup_req/1)},
+     {"E-RAB SETUP RESPONSE",
+      ?TC(fun test_e_rab_setup_rsp/1)},
+     {"E-RAB MODIFICATION INDICATION",
+      ?TC(fun test_e_rab_modify_ind/1)},
+     {"INITIAL CONTEXT SETUP REQUEST",
+      ?TC(fun test_initial_context_setup_req/1)},
+     {"INITIAL CONTEXT SETUP RESPONSE",
+      ?TC(fun test_initial_context_setup_rsp/1)}.
+
+
+%% ------------------------------------------------------------------
+%% actual testcases
 %% ------------------------------------------------------------------
 
 %% S1 SETUP REQUEST
@@ -17,10 +54,10 @@
        16#0c, 16#0e, 16#40, 16#00, 16#f1, 16#10
     >>.
 
-s1_setup_req_test() ->
+test_s1_setup_req(S) ->
     OrigData = s1_setup_req_pdu(),
     %% Expect the PDU to be proxied unmodified
-    ?assertEqual(OrigData, s1ap_proxy:handle_pdu(OrigData)).
+    ?_assertEqual({OrigData, S}, s1ap_proxy:handle_pdu(OrigData, S)).
 
 
 %% eNB -> MME E-RAB SETUP REQUEST
@@ -50,7 +87,7 @@
        16#16, 16#00, 16#15, 16#00, 16#10, 16#02, 16#05, 16#78
     >>.
 
-e_rab_setup_req_test() ->
+test_e_rab_setup_req(S) ->
     %% Original input data
     TEID = << 16#00, 16#00, 16#00, 16#18 >>,
     OrigTLA = << 16#ac, 16#16, 16#00, 16#06 >>,
@@ -60,7 +97,7 @@
     ExpData = e_rab_setup_req_pdu(?EXP_ADDR_BIN, TEID),
 
     application:set_env(osmo_s1gw, mme_loc_addr, ?EXP_ADDR_STR),
-    ?assertEqual(ExpData, s1ap_proxy:handle_pdu(OrigData)).
+    ?_assertMatch({ExpData, _}, s1ap_proxy:handle_pdu(OrigData, S)).
 
 
 %% MME -> eNB E-RAB SETUP RESPONSE
@@ -74,7 +111,7 @@
        TEID/bytes %% GTP-TEID
     >>.
 
-e_rab_setup_rsp_test() ->
+test_e_rab_setup_rsp(S) ->
     %% Original input data
     TEID = << 16#6c, 16#05, 16#bf, 16#56 >>,
     OrigTLA = << 16#c0, 16#a8, 16#68, 16#a7 >>,
@@ -84,7 +121,7 @@
     ExpData = e_rab_setup_rsp_pdu(?EXP_ADDR_BIN, TEID),
 
     application:set_env(osmo_s1gw, s1gw_bind_addr, ?EXP_ADDR_STR),
-    ?assertEqual(ExpData, s1ap_proxy:handle_pdu(OrigData)).
+    ?_assertMatch({ExpData, _}, s1ap_proxy:handle_pdu(OrigData, S)).
 
 
 %% eNB -> MME E-RAB MODIFICATION INDICATION
@@ -98,7 +135,7 @@
        TEID/bytes %% GTP-TEID
     >>.
 
-e_rab_modify_ind_test() ->
+test_e_rab_modify_ind(S) ->
     %% Original input data
     TEID = << 16#3d, 16#b0, 16#b5, 16#1d >>,
     OrigTLA = << 16#c0, 16#a8, 16#12, 16#c6 >>,
@@ -108,7 +145,7 @@
     ExpData = e_rab_modify_ind_pdu(?EXP_ADDR_BIN, TEID),
 
     application:set_env(osmo_s1gw, mme_loc_addr, ?EXP_ADDR_STR),
-    ?assertEqual(ExpData, s1ap_proxy:handle_pdu(OrigData)).
+    ?_assertMatch({ExpData, _}, s1ap_proxy:handle_pdu(OrigData, S)).
 
 
 %% eNB -> MME INITIAL CONTEXT SETUP REQUEST
@@ -153,7 +190,7 @@
        16#10, 16#03, 16#ff, 16#ff, 16#74
     >>.
 
-initial_context_setup_req_test() ->
+test_initial_context_setup_req(S) ->
     %% Original input data
     TEID = << 16#00, 16#00, 16#71, 16#23 >>,
     OrigTLA = << 16#c0, 16#a8, 16#02, 16#d2 >>,
@@ -163,7 +200,7 @@
     ExpData = initial_context_setup_req_pdu(?EXP_ADDR_BIN, TEID),
 
     application:set_env(osmo_s1gw, mme_loc_addr, ?EXP_ADDR_STR),
-    ?assertEqual(ExpData, s1ap_proxy:handle_pdu(OrigData)).
+    ?_assertMatch({ExpData, _}, s1ap_proxy:handle_pdu(OrigData, S)).
 
 
 %% MME -> eNB INITIAL CONTEXT SETUP RESPONSE
@@ -177,7 +214,7 @@
        TEID/bytes %% GTP-TEID
     >>.
 
-initial_context_setup_rsp_test() ->
+test_initial_context_setup_rsp(S) ->
     %% Original input data
     TEID = << 16#00, 16#00, 16#00, 16#01 >>,
     OrigTLA = << 16#c0, 16#a8, 16#02, 16#cb >>,
@@ -187,6 +224,6 @@
     ExpData = initial_context_setup_rsp_pdu(?EXP_ADDR_BIN, TEID),
 
     application:set_env(osmo_s1gw, s1gw_bind_addr, ?EXP_ADDR_STR),
-    ?assertEqual(ExpData, s1ap_proxy:handle_pdu(OrigData)).
+    ?_assertMatch({ExpData, _}, s1ap_proxy:handle_pdu(OrigData, S)).
 
 %% vim:set ts=4 sw=4 et: