1/* Test of u8_mbtoucr() function. 2 Copyright (C) 2010 Free Software Foundation, Inc. 3 4 This program is free software: you can redistribute it and/or modify 5 it under the terms of the GNU General Public License as published by 6 the Free Software Foundation; either version 3 of the License, or 7 (at your option) any later version. 8 9 This program is distributed in the hope that it will be useful, 10 but WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 GNU General Public License for more details. 13 14 You should have received a copy of the GNU General Public License 15 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 16 17/* Written by Bruno Haible <bruno@clisp.org>, 2010. */ 18 19#include <config.h> 20 21#include "unistr.h" 22 23#include "macros.h" 24 25int 26main () 27{ 28 ucs4_t uc; 29 int ret; 30 31 /* Test NUL unit input. */ 32 { 33 static const uint8_t input[] = ""; 34 uc = 0xBADFACE; 35 ret = u8_mbtoucr (&uc, input, 1); 36 ASSERT (ret == 1); 37 ASSERT (uc == 0); 38 } 39 40 /* Test ISO 646 unit input. */ 41 { 42 ucs4_t c; 43 uint8_t buf[1]; 44 45 for (c = 0; c < 0x80; c++) 46 { 47 buf[0] = c; 48 uc = 0xBADFACE; 49 ret = u8_mbtoucr (&uc, buf, 1); 50 ASSERT (ret == 1); 51 ASSERT (uc == c); 52 } 53 } 54 55 /* Test 2-byte character input. */ 56 { 57 static const uint8_t input[] = { 0xC3, 0x97 }; 58 uc = 0xBADFACE; 59 ret = u8_mbtoucr (&uc, input, 2); 60 ASSERT (ret == 2); 61 ASSERT (uc == 0x00D7); 62 } 63 64 /* Test 3-byte character input. */ 65 { 66 static const uint8_t input[] = { 0xE2, 0x82, 0xAC }; 67 uc = 0xBADFACE; 68 ret = u8_mbtoucr (&uc, input, 3); 69 ASSERT (ret == 3); 70 ASSERT (uc == 0x20AC); 71 } 72 73 /* Test 4-byte character input. */ 74 { 75 static const uint8_t input[] = { 0xF4, 0x8F, 0xBF, 0xBD }; 76 uc = 0xBADFACE; 77 ret = u8_mbtoucr (&uc, input, 4); 78 ASSERT (ret == 4); 79 ASSERT (uc == 0x10FFFD); 80 } 81 82 /* Test incomplete/invalid 1-byte input. */ 83 { 84 static const uint8_t input[] = { 0xC1 }; 85 uc = 0xBADFACE; 86 ret = u8_mbtoucr (&uc, input, 1); 87 ASSERT (ret == -1); 88 ASSERT (uc == 0xFFFD); 89 } 90 { 91 static const uint8_t input[] = { 0xC3 }; 92 uc = 0xBADFACE; 93 ret = u8_mbtoucr (&uc, input, 1); 94 ASSERT (ret == -2); 95 ASSERT (uc == 0xFFFD); 96 } 97 { 98 static const uint8_t input[] = { 0xE2 }; 99 uc = 0xBADFACE; 100 ret = u8_mbtoucr (&uc, input, 1); 101 ASSERT (ret == -2); 102 ASSERT (uc == 0xFFFD); 103 } 104 { 105 static const uint8_t input[] = { 0xF4 }; 106 uc = 0xBADFACE; 107 ret = u8_mbtoucr (&uc, input, 1); 108 ASSERT (ret == -2); 109 ASSERT (uc == 0xFFFD); 110 } 111 { 112 static const uint8_t input[] = { 0xFE }; 113 uc = 0xBADFACE; 114 ret = u8_mbtoucr (&uc, input, 1); 115 ASSERT (ret == -1); 116 ASSERT (uc == 0xFFFD); 117 } 118 119 /* Test incomplete/invalid 2-byte input. */ 120 { 121 static const uint8_t input[] = { 0xE0, 0x9F }; 122 uc = 0xBADFACE; 123 ret = u8_mbtoucr (&uc, input, 2); 124 ASSERT (ret == -1); 125 ASSERT (uc == 0xFFFD); 126 } 127 { 128 static const uint8_t input[] = { 0xE2, 0x82 }; 129 uc = 0xBADFACE; 130 ret = u8_mbtoucr (&uc, input, 2); 131 ASSERT (ret == -2); 132 ASSERT (uc == 0xFFFD); 133 } 134 { 135 static const uint8_t input[] = { 0xE2, 0xD0 }; 136 uc = 0xBADFACE; 137 ret = u8_mbtoucr (&uc, input, 2); 138 ASSERT (ret == -1); 139 ASSERT (uc == 0xFFFD); 140 } 141 { 142 static const uint8_t input[] = { 0xF0, 0x8F }; 143 uc = 0xBADFACE; 144 ret = u8_mbtoucr (&uc, input, 2); 145 ASSERT (ret == -1); 146 ASSERT (uc == 0xFFFD); 147 } 148 { 149 static const uint8_t input[] = { 0xF3, 0x8F }; 150 uc = 0xBADFACE; 151 ret = u8_mbtoucr (&uc, input, 2); 152 ASSERT (ret == -2); 153 ASSERT (uc == 0xFFFD); 154 } 155 { 156 static const uint8_t input[] = { 0xF3, 0xD0 }; 157 uc = 0xBADFACE; 158 ret = u8_mbtoucr (&uc, input, 2); 159 ASSERT (ret == -1); 160 ASSERT (uc == 0xFFFD); 161 } 162 163 /* Test incomplete/invalid 3-byte input. */ 164 { 165 static const uint8_t input[] = { 0xF3, 0x8F, 0xBF }; 166 uc = 0xBADFACE; 167 ret = u8_mbtoucr (&uc, input, 3); 168 ASSERT (ret == -2); 169 ASSERT (uc == 0xFFFD); 170 } 171 { 172 static const uint8_t input[] = { 0xF3, 0xD0, 0xBF }; 173 uc = 0xBADFACE; 174 ret = u8_mbtoucr (&uc, input, 3); 175 ASSERT (ret == -1); 176 ASSERT (uc == 0xFFFD); 177 } 178 { 179 static const uint8_t input[] = { 0xF3, 0x8F, 0xD0 }; 180 uc = 0xBADFACE; 181 ret = u8_mbtoucr (&uc, input, 3); 182 ASSERT (ret == -1); 183 ASSERT (uc == 0xFFFD); 184 } 185 186 return 0; 187} 188