Home | History | Annotate | Download | only in tests 
      1 ///////////////////////////////////////////////////////////////////////////////
      2 //
      3 // Copyright (c) 2015 Microsoft Corporation. All rights reserved.
      4 //
      5 // This code is licensed under the MIT License (MIT).
      6 //
      7 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      8 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      9 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
     10 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     11 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     12 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     13 // THE SOFTWARE.
     14 //
     15 ///////////////////////////////////////////////////////////////////////////////
     16 
     17 #include <catch/catch.hpp>
     18 
     19 #include <gsl/gsl>
     20 
     21 #include <functional>
     22 
     23 using namespace gsl;
     24 
     25 void f(int& i) { i += 1; }
     26 
     27 TEST_CASE("finally_lambda")
     28 {
     29     int i = 0;
     30     {
     31         auto _ = finally([&]() { f(i); });
     32         CHECK(i == 0);
     33     }
     34     CHECK(i == 1);
     35 }
     36 
     37 TEST_CASE("finally_lambda_move")
     38 {
     39     int i = 0;
     40     {
     41         auto _1 = finally([&]() { f(i); });
     42         {
     43             auto _2 = std::move(_1);
     44             CHECK(i == 0);
     45         }
     46         CHECK(i == 1);
     47         {
     48             auto _2 = std::move(_1);
     49             CHECK(i == 1);
     50         }
     51         CHECK(i == 1);
     52     }
     53     CHECK(i == 1);
     54 }
     55 
     56 TEST_CASE("finally_function_with_bind")
     57 {
     58     int i = 0;
     59     {
     60         auto _ = finally(std::bind(&f, std::ref(i)));
     61         CHECK(i == 0);
     62     }
     63     CHECK(i == 1);
     64 }
     65 
     66 int j = 0;
     67 void g() { j += 1; }
     68 TEST_CASE("finally_function_ptr")
     69 {
     70     j = 0;
     71     {
     72         auto _ = finally(&g);
     73         CHECK(j == 0);
     74     }
     75     CHECK(j == 1);
     76 }
     77 
     78 TEST_CASE("narrow_cast")
     79 {
     80     int n = 120;
     81     char c = narrow_cast<char>(n);
     82     CHECK(c == 120);
     83 
     84     n = 300;
     85     unsigned char uc = narrow_cast<unsigned char>(n);
     86     CHECK(uc == 44);
     87 }
     88 
     89 TEST_CASE("narrow")
     90 {
     91     int n = 120;
     92     const char c = narrow<char>(n);
     93     CHECK(c == 120);
     94 
     95     n = 300;
     96     CHECK_THROWS_AS(narrow<char>(n), narrowing_error);
     97 
     98     const auto int32_max = std::numeric_limits<int32_t>::max();
     99     const auto int32_min = std::numeric_limits<int32_t>::min();
    100 
    101     CHECK(narrow<uint32_t>(int32_t(0)) == 0);
    102     CHECK(narrow<uint32_t>(int32_t(1)) == 1);
    103     CHECK(narrow<uint32_t>(int32_max) == static_cast<uint32_t>(int32_max));
    104 
    105     CHECK_THROWS_AS(narrow<uint32_t>(int32_t(-1)), narrowing_error);
    106     CHECK_THROWS_AS(narrow<uint32_t>(int32_min), narrowing_error);
    107 
    108     n = -42;
    109     CHECK_THROWS_AS(narrow<unsigned>(n), narrowing_error);
    110 }
    111