Embed:
(wiki syntax)
Show/hide line numbers
stoip6test.cpp
00001 /* 00002 * Copyright (c) 2015 ARM Limited. All rights reserved. 00003 * SPDX-License-Identifier: Apache-2.0 00004 * Licensed under the Apache License, Version 2.0 (the License); you may 00005 * not use this file except in compliance with the License. 00006 * You may obtain a copy of the License at 00007 * 00008 * http://www.apache.org/licenses/LICENSE-2.0 00009 * 00010 * Unless required by applicable law or agreed to in writing, software 00011 * distributed under the License is distributed on an AS IS BASIS, WITHOUT 00012 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00013 * See the License for the specific language governing permissions and 00014 * limitations under the License. 00015 */ 00016 #include "CppUTest/TestHarness.h" 00017 #include "ip6string.h" 00018 #include "ipv6_test_values.h" 00019 #include <stdlib.h> 00020 #include <string.h> 00021 00022 TEST_GROUP(stoip6) 00023 { 00024 void setup() { 00025 } 00026 00027 void teardown() { 00028 } 00029 }; 00030 00031 TEST(stoip6, ZeroAddress) 00032 { 00033 for (int i = 0; ipv6_test_values[i].addr; i++) { 00034 uint8_t ip[16]; 00035 char *addr = ipv6_test_values[i].addr; 00036 stoip6(addr, strlen(addr), ip); 00037 CHECK(0 == memcmp(ip, ipv6_test_values[i].bin, 16)); 00038 } 00039 } 00040 00041 TEST(stoip6, TooShort) 00042 { 00043 char *addr = "FFFF:FFFF:"; 00044 uint8_t ip[16]; 00045 uint8_t correct[16] = {0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 00046 // This should sto parsing when too short address given, the buffer hoewever is filled to that long 00047 // So basically there is no error handling. We just check that first FFFF:FFFF gets filled and not trash after that. 00048 // Rest should be filled with zeroes 00049 stoip6(addr, strlen(addr), ip); 00050 CHECK(0 == memcmp(ip, correct, 16)); 00051 } 00052 00053 TEST(stoip6, TooLongString) 00054 { 00055 // String len must be less than 40, otherwise not valid 00056 char *addr = "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:"; 00057 uint8_t ip[16] = {0}; 00058 uint8_t correct[16] = {0}; 00059 // This should not fill anything, too long string. 00060 // This is basically only validation we do 00061 stoip6(addr, strlen(addr), ip); 00062 CHECK(0 == memcmp(ip, correct, 16)); 00063 } 00064 00065 TEST(stoip6, TooManyFields) 00066 { 00067 // String len must be less than 40 00068 char *addr = "FF:FF:FF:FF:FF:FF:FFFF:FFFF:FFFF:FFFF:"; 00069 uint8_t ip[17] = {0}; 00070 uint8_t correct[17] = { 0, 0xff, 0, 0xff, 0, 0xff, 0, 0xff, 0, 0xff, 0, 0xff, 0xff, 0xff, 0xff, 0xff, 0}; 00071 // Again.. there is not really any error handling (no return value) 00072 // Just make sure that it does not overflow 00073 stoip6(addr, strlen(addr), ip); 00074 CHECK(0 == memcmp(ip, correct, 17)); // Note, we are checking 17, to make sure one byte after address in not touched. 00075 } 00076 00077 TEST(stoip6, Prefixlen) 00078 { 00079 CHECK(0 == sipv6_prefixlength("::")); 00080 CHECK(64 == sipv6_prefixlength("::/64")); 00081 } 00082 00083 // This test revealed a off-by-one error in stoip6() when the code was ran under valgrind. 00084 // The IP address is copied from the test_2duts_ping -test, where the valgrind message 00085 // was originally spotted. 00086 TEST(stoip6, RegressionTestForOffByOne) 00087 { 00088 const char *sourceAddr = "fd00:db8::643f:f54a:ec29:cdbb"; 00089 00090 // Use heap based test string to make valgrind spot the problem. 00091 char *sourceTemp = (char *)strdup(sourceAddr); 00092 size_t sourceTempLen = strlen(sourceTemp); 00093 00094 uint8_t ip[16]; 00095 const uint8_t correct[16] = { 0xfd, 0x00, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00, 00096 0x64, 0x3f, 0xf5, 0x4a, 0xec, 0x29, 0xcd, 0xbb 00097 }; 00098 00099 stoip6(sourceTemp, sourceTempLen, ip); 00100 00101 CHECK(0 == memcmp(ip, correct, 16)); 00102 00103 free(sourceTemp); 00104 } 00105 00106 /***********************************************************/ 00107 /* Second test group for the old tests that were once lost */ 00108 00109 const char string_addr[][40] = 00110 { 00111 "2001:db8::1:0:0:1", // 1 00112 "2001:db8:aaaa:bbbb:cccc:dddd:eeee:1", // 2 00113 "2001:db8::1", // 3 00114 "2001:db8::2:1", // 4 00115 "2001:db8:aaaa:bbbb:cccc:dddd:0:1", // 5 00116 "2001:db8::aaaa:0:0:1", // 6 00117 "2001:0:0:1::1", // 7 00118 "2001:0:0:1::", // 8 00119 "2001:db8::", // 9 00120 "::aaaa:0:0:1", // 10 00121 "::1", // 11 00122 "::", // 12 00123 }; 00124 00125 00126 const uint8_t hex_addr[][16] = 00127 { 00128 { 0x20, 0x01, 0xd, 0xb8, 0,0,0,0,0,1,0,0,0,0,0,1 }, 00129 { 0x20, 0x01, 0xd, 0xb8, 0xaa, 0xaa, 0xbb, 0xbb, 0xcc, 0xcc, 0xdd, 0xdd, 0xee, 0xee, 0x00, 0x01 }, 00130 { 0x20, 0x01, 0xd, 0xb8, 0,0,0,0,0,0,0,0,0,0,0,1 }, 00131 { 0x20, 0x01, 0xd,0xb8, 0,0,0,0,0,0,0,0, 0,2,0,1 }, 00132 { 0x20, 0x01, 0xd, 0xb8, 0xaa, 0xaa, 0xbb, 0xbb, 0xcc, 0xcc, 0xdd, 0xdd, 0,0, 0x00, 0x01 }, 00133 { 0x20, 0x01, 0xd, 0xb8, 0,0,0,0,0xaa,0xaa,0,0,0,0,0,1 }, 00134 { 0x20, 0x01, 0,0 ,0,0 ,0,1,0,0,0,0,0,0,0,1 }, 00135 { 0x20, 0x01, 0,0 ,0,0 ,0,1,0,0,0,0,0,0,0,0 }, 00136 { 0x20, 0x01, 0xd, 0xb8 }, 00137 { 0,0,0,0,0,0,0,0,0xaa,0xaa,0,0,0,0,0,1 }, 00138 { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, 00139 { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, 00140 }; 00141 00142 char buf[40]; 00143 int i = 0; 00144 00145 TEST_GROUP(stoip6_2) 00146 { 00147 void setUp(void) 00148 { 00149 memset(buf, 0, 40); 00150 } 00151 00152 void tearDown(void) 00153 { 00154 i++; 00155 } 00156 }; 00157 00158 /* Unity test code starts */ 00159 00160 00161 TEST(stoip6_2, test_2_1) 00162 { 00163 i = 0; 00164 stoip6(string_addr[i], strlen(string_addr[i]), buf); 00165 CHECK(0 == memcmp(hex_addr[i], buf, strlen(buf))); 00166 } 00167 00168 TEST(stoip6_2, test_2_2) 00169 { 00170 stoip6(string_addr[i], strlen(string_addr[i]), buf); 00171 CHECK(0 == memcmp(hex_addr[i], buf, strlen(buf))); 00172 } 00173 TEST(stoip6_2, test_2_3) 00174 { 00175 stoip6(string_addr[i], strlen(string_addr[i]), buf); 00176 CHECK(0 == memcmp(hex_addr[i], buf, strlen(buf))); 00177 } 00178 TEST(stoip6_2, test_2_4) 00179 { 00180 stoip6(string_addr[i], strlen(string_addr[i]), buf); 00181 CHECK(0 == memcmp(hex_addr[i], buf, strlen(buf))); 00182 } 00183 TEST(stoip6_2, test_2_5) 00184 { 00185 stoip6(string_addr[i], strlen(string_addr[i]), buf); 00186 CHECK(0 == memcmp(hex_addr[i], buf, strlen(buf))); 00187 } 00188 TEST(stoip6_2, test_2_6) 00189 { 00190 stoip6(string_addr[i], strlen(string_addr[i]), buf); 00191 CHECK(0 == memcmp(hex_addr[i], buf, strlen(buf))); 00192 } 00193 TEST(stoip6_2, test_2_7) 00194 { 00195 stoip6(string_addr[i], strlen(string_addr[i]), buf); 00196 CHECK(0 == memcmp(hex_addr[i], buf, strlen(buf))); 00197 } 00198 TEST(stoip6_2, test_2_8) 00199 { 00200 stoip6(string_addr[i], strlen(string_addr[i]), buf); 00201 CHECK(0 == memcmp(hex_addr[i], buf, strlen(buf))); 00202 } 00203 TEST(stoip6_2, test_2_9) 00204 { 00205 stoip6(string_addr[i], strlen(string_addr[i]), buf); 00206 CHECK(0 == memcmp(hex_addr[i], buf, strlen(buf))); 00207 } 00208 TEST(stoip6_2, test_2_10) 00209 { 00210 stoip6(string_addr[i], strlen(string_addr[i]), buf); 00211 CHECK(0 == memcmp(hex_addr[i], buf, 16)); 00212 } 00213 TEST(stoip6_2, test_2_11) 00214 { 00215 stoip6(string_addr[i], strlen(string_addr[i]), buf); 00216 CHECK(0 == memcmp(hex_addr[i], buf, 16)); 00217 } 00218 TEST(stoip6_2, test_2_12) 00219 { 00220 stoip6(string_addr[i], strlen(string_addr[i]), buf); 00221 CHECK(0 == memcmp(hex_addr[i], buf, 16)); 00222 } 00223
Generated on Tue Jul 12 2022 12:22:22 by
1.7.2