1// Copyright 2014 The Kyua Authors. 2// All rights reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are 6// met: 7// 8// * Redistributions of source code must retain the above copyright 9// notice, this list of conditions and the following disclaimer. 10// * Redistributions in binary form must reproduce the above copyright 11// notice, this list of conditions and the following disclaimer in the 12// documentation and/or other materials provided with the distribution. 13// * Neither the name of Google Inc. nor the names of its contributors 14// may be used to endorse or promote products derived from this software 15// without specific prior written permission. 16// 17// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 29#include "utils/format/containers.ipp" 30 31#include <memory> 32#include <ostream> 33#include <set> 34#include <string> 35#include <utility> 36#include <vector> 37 38#include <atf-c++.hpp> 39 40 41 42namespace { 43 44 45/// Formats a value and compares it to an expected string. 46/// 47/// \tparam T The type of the value to format. 48/// \param expected Expected formatted text. 49/// \param actual The value to format. 50/// 51/// \post Fails the test case if the formatted actual value does not match 52/// the provided expected string. 53template< typename T > 54static void 55do_check(const char* expected, const T& actual) 56{ 57 std::ostringstream str; 58 str << actual; 59 ATF_REQUIRE_EQ(expected, str.str()); 60} 61 62 63} // anonymous namespace 64 65 66ATF_TEST_CASE_WITHOUT_HEAD(std_map__empty); 67ATF_TEST_CASE_BODY(std_map__empty) 68{ 69 do_check("map()", std::map< char, char >()); 70 do_check("map()", std::map< int, long >()); 71} 72 73 74ATF_TEST_CASE_WITHOUT_HEAD(std_map__some); 75ATF_TEST_CASE_BODY(std_map__some) 76{ 77 { 78 std::map< char, int > v; 79 v['b'] = 123; 80 v['z'] = 321; 81 do_check("map(b=123, z=321)", v); 82 } 83 84 { 85 std::map< int, std::string > v; 86 v[5] = "first"; 87 v[2] = "second"; 88 v[8] = "third"; 89 do_check("map(2=second, 5=first, 8=third)", v); 90 } 91} 92 93 94ATF_TEST_CASE_WITHOUT_HEAD(std_pair); 95ATF_TEST_CASE_BODY(std_pair) 96{ 97 do_check("pair(5, b)", std::pair< int, char >(5, 'b')); 98 do_check("pair(foo bar, baz)", 99 std::pair< std::string, std::string >("foo bar", "baz")); 100} 101 102 103ATF_TEST_CASE_WITHOUT_HEAD(std_shared_ptr__null); 104ATF_TEST_CASE_BODY(std_shared_ptr__null) 105{ 106 do_check("<NULL>", std::shared_ptr< char >()); 107 do_check("<NULL>", std::shared_ptr< int >()); 108} 109 110 111ATF_TEST_CASE_WITHOUT_HEAD(std_shared_ptr__not_null); 112ATF_TEST_CASE_BODY(std_shared_ptr__not_null) 113{ 114 do_check("f", std::shared_ptr< char >(new char('f'))); 115 do_check("8", std::shared_ptr< int >(new int(8))); 116} 117 118 119ATF_TEST_CASE_WITHOUT_HEAD(std_set__empty); 120ATF_TEST_CASE_BODY(std_set__empty) 121{ 122 do_check("set()", std::set< char >()); 123 do_check("set()", std::set< int >()); 124} 125 126 127ATF_TEST_CASE_WITHOUT_HEAD(std_set__some); 128ATF_TEST_CASE_BODY(std_set__some) 129{ 130 { 131 std::set< char > v; 132 v.insert('b'); 133 v.insert('z'); 134 do_check("set(b, z)", v); 135 } 136 137 { 138 std::set< int > v; 139 v.insert(5); 140 v.insert(2); 141 v.insert(8); 142 do_check("set(2, 5, 8)", v); 143 } 144} 145 146 147ATF_TEST_CASE_WITHOUT_HEAD(std_vector__empty); 148ATF_TEST_CASE_BODY(std_vector__empty) 149{ 150 do_check("[]", std::vector< char >()); 151 do_check("[]", std::vector< int >()); 152} 153 154 155ATF_TEST_CASE_WITHOUT_HEAD(std_vector__some); 156ATF_TEST_CASE_BODY(std_vector__some) 157{ 158 { 159 std::vector< char > v; 160 v.push_back('b'); 161 v.push_back('z'); 162 do_check("[b, z]", v); 163 } 164 165 { 166 std::vector< int > v; 167 v.push_back(5); 168 v.push_back(2); 169 v.push_back(8); 170 do_check("[5, 2, 8]", v); 171 } 172} 173 174 175ATF_INIT_TEST_CASES(tcs) 176{ 177 ATF_ADD_TEST_CASE(tcs, std_map__empty); 178 ATF_ADD_TEST_CASE(tcs, std_map__some); 179 180 ATF_ADD_TEST_CASE(tcs, std_pair); 181 182 ATF_ADD_TEST_CASE(tcs, std_shared_ptr__null); 183 ATF_ADD_TEST_CASE(tcs, std_shared_ptr__not_null); 184 185 ATF_ADD_TEST_CASE(tcs, std_set__empty); 186 ATF_ADD_TEST_CASE(tcs, std_set__some); 187 188 ATF_ADD_TEST_CASE(tcs, std_vector__empty); 189 ATF_ADD_TEST_CASE(tcs, std_vector__some); 190} 191