authorgravatar for hello@nektro.netMeghan Denny <hello@nektro.net> 2026-01-18 23:51:44 -08:00
committergravatar for hello@nektro.netMeghan Denny <hello@nektro.net> 2026-01-18 23:51:44 -08:00
logf8e9e53b4f547ebc4f926a6c4cd67fe8055a1db0
tree993b1f3f4fa3c73826576b27ceb0503e2a802d09
parent0bf65d58bbc8abb3a1d7f33b23f80f8f3b52243f

pass toUnicodePass

All 664 tests passed.

7 files changed, 1368 insertions(+), 1 deletions(-)

generate.ts+86-1
......@@ -1,6 +1,28 @@
11import { closeSync, openSync } from "node:fs";
22
33const unicode_version = "17.0.0";
4const encoder = new TextEncoder();
5
6function stringEscape(s?: string) {
7 if (!s) return "";
8 return Array.from(encoder.encode(s.replace(/\\u([0-9A-F]{4})/g, (s) => String.fromCodePoint(parseInt(s.slice(2), 16)))))
9 .map((x) => {
10 if (x === 0x09) return "\\t";
11 if (x === 0x0a) return "\\n";
12 if (x === 0x0d) return "\\r";
13 if (x === 0x20) return " ";
14 if (x === 0x21) return "!";
15 if (x === 0x22) return `\\"`;
16 if (x >= 0x23 && x <= 0x26) return String.fromCodePoint(x);
17 if (x === 0x27) return "'";
18 if (x >= 0x28 && x <= 0x5b) return String.fromCodePoint(x);
19 if (x === 0x5c) return "\\\\";
20 if (x >= 0x5d && x <= 0x7e) return String.fromCodePoint(x);
21 return `\\x${x.toString(16).padStart(2, "0")}`;
22 })
23 .join("");
24}
25const E = stringEscape;
426
527{
628 const source = `https://www.unicode.org/Public/${unicode_version}/idna/IdnaMappingTable.txt`;
......@@ -152,9 +174,72 @@ const unicode_version = "17.0.0";
152174 w.write(`\n`);
153175 w.write(`// Based on the source file: ${source}\n`);
154176 w.write(`//\n`);
177 w.write(`// zig fmt: off\n`);
155178 w.write(`\n`);
179 w.write(`const std = @import("std");\n`);
180 w.write(`const idna = @import("unicode-idna");\n`);
181 w.write(`const expect = @import("expect").expect;\n`);
182
183 w.write(`
184fn toUnicodePass(
185 source: []const u8,
186 expected: []const u8,
187) !void {
188 const allocator = std.testing.allocator;
189 const result = try idna.ToUnicode(allocator, source, true, true, true, true, false, false);
190 defer allocator.free(result);
191 try expect(result).toEqualString(expected);
192}
156193
157 //TODO:
194fn toUnicodeFail(
195 source: []const u8,
196) !void {
197 const allocator = std.testing.allocator;
198 const result = idna.ToUnicode(allocator, source, true, true, true, true, false, false) catch |err| switch (err) {
199 error.IDNAFailure => return,
200 error.OutOfMemory => return error.OutOfMemory,
201 };
202 defer allocator.free(result);
203 return error.ShouldHaveFailed;
204}
205
206fn toAsciiPass(
207 source: []const u8,
208 expected: []const u8,
209 Transitional_Processing: bool,
210) !void {
211 const allocator = std.testing.allocator;
212 const result = try idna.ToASCII(allocator, source, true, true, true, true, Transitional_Processing, true, false);
213 defer allocator.free(result);
214 try expect(result).toEqualString(expected);
215}
216
217fn toAsciiFail(
218 source: []const u8,
219 Transitional_Processing: bool,
220) !void {
221 const allocator = std.testing.allocator;
222 const result = idna.ToASCII(allocator, source, true, true, true, true, Transitional_Processing, true, false) catch |err| switch (err) {
223 error.IDNAFailure => return,
224 error.OutOfMemory => return error.OutOfMemory,
225 };
226 defer allocator.free(result);
227 return error.ShouldHaveFailed;
228}
229`);
230 w.write(`\n`);
231
232 for (const i of cols) {
233 const source = i[0];
234 const toUnicode = i[1] || source;
235 const toUnicodeStatus = i[2] || "[]";
236 const toAsciiN = i[3] || toUnicode;
237 const toAsciiNStatus = i[4] || toUnicodeStatus;
238 const toAsciiT = i[5] || toAsciiN;
239 const toAsciiTStatus = i[6] || toAsciiNStatus;
240
241 if (toUnicodeStatus === "[]") w.write(`test { try toUnicodePass("${E(source)}", "${E(toUnicode)}"); }\n`);
242 }
158243
159244 w.flush();
160245}
idna.zig+188
......@@ -1,5 +1,193 @@
11const std = @import("std");
2const extras = @import("extras");
3const ucd = @import("unicode-ucd");
4const normalization = @import("./normalization.zig");
5const punycode = @import("./punycode.zig");
26
37pub const @"2008" = @import("./2008.zig");
48
59pub const table = @import("./table.zig");
10
11pub fn ToASCII(
12 allocator: std.mem.Allocator,
13 domain_name: []const u8,
14 CheckHyphens: bool,
15 CheckBidi: bool,
16 CheckJoiners: bool,
17 UseSTD3ASCIIRules: bool,
18 Transitional_Processing: bool, //deprecated
19 VerifyDnsLength: bool,
20 IgnoreInvalidPunycode: bool,
21) ![]u8 {
22 // if (extras.matchesAll(u8, domain_name, std.ascii.isAscii)) return allocator.dupe(u8, domain_name);
23
24 var map = extras.ManyArrayList(u8).init(allocator);
25 defer map.deinit();
26
27 try Processing(&map, domain_name, UseSTD3ASCIIRules, CheckHyphens, CheckBidi, CheckJoiners, Transitional_Processing, IgnoreInvalidPunycode);
28
29 map.lengths.clearRetainingCapacity();
30 var it2 = std.mem.splitScalar(u8, map.list.items, '.');
31 while (it2.next()) |label| {
32 try map.lengths.append(map.allocator, label.len);
33 try map.lengths.append(map.allocator, 1);
34 }
35 _ = map.lengths.orderedRemove(map.lengths.items.len - 1);
36 for (0..map.lengths.items.len) |n| {
37 punycode.encode(&map, n) catch |err| switch (err) {
38 error.InvalidPunycode => return error.IDNAFailure,
39 };
40 }
41
42 if (VerifyDnsLength) {
43 //
44 }
45
46 return map.toOwnedSlice();
47}
48
49pub fn ToUnicode(
50 allocator: std.mem.Allocator,
51 domain_name: []const u8,
52 CheckHyphens: bool,
53 CheckBidi: bool,
54 CheckJoiners: bool,
55 UseSTD3ASCIIRules: bool,
56 Transitional_Processing: bool, //deprecated
57 IgnoreInvalidPunycode: bool,
58) ![]u8 {
59 // if (extras.matchesAll(u8, domain_name, std.ascii.isAscii)) return allocator.dupe(u8, domain_name);
60 var map = extras.ManyArrayList(u8).init(allocator);
61 defer map.deinit();
62 try Processing(&map, domain_name, UseSTD3ASCIIRules, CheckHyphens, CheckBidi, CheckJoiners, Transitional_Processing, IgnoreInvalidPunycode);
63 return map.toOwnedSlice();
64}
65
66fn Processing(
67 map: *extras.ManyArrayList(u8),
68 domain_name: []const u8,
69 UseSTD3ASCIIRules: bool,
70 CheckHyphens: bool,
71 CheckBidi: bool,
72 CheckJoiners: bool,
73 Transitional_Processing: bool, //deprecated
74 IgnoreInvalidPunycode: bool,
75) !void {
76 try map.list.ensureUnusedCapacity(map.allocator, domain_name.len);
77 try map.lengths.ensureUnusedCapacity(map.allocator, domain_name.len);
78 // 1. Map. For each code point in the domain_name string, look up the Status value in Section 5, IDNA Mapping Table, and take the following actions:
79 var it = std.unicode.Utf8View.initUnchecked(domain_name).iterator();
80 while (it.nextCodepointSlice()) |sl| {
81 const cp = std.unicode.utf8Decode(sl) catch unreachable;
82 const status, const mapping, const status2 = mappingRow(cp);
83 _ = status2;
84 sw: switch (status) {
85 .valid => {
86 try map.appendSlice(try map.add(), sl);
87 },
88 .ignored => {
89 //nop
90 },
91 .mapped => {
92 if (Transitional_Processing and cp == 'ẞ') {
93 try map.appendSlice(try map.add(), "s");
94 try map.appendSlice(try map.add(), "s");
95 continue;
96 }
97 for (mapping) |p| {
98 var buf: [4]u8 = undefined;
99 const l = std.unicode.utf8Encode(p, &buf) catch unreachable;
100 try map.appendSlice(try map.add(), buf[0..l]);
101 }
102 },
103 .deviation => {
104 continue :sw if (Transitional_Processing) .mapped else .valid;
105 },
106 .disallowed => {
107 continue :sw .valid;
108 },
109 }
110 }
111
112 // 2. Normalize. Normalize the domain_name string to Unicode Normalization Form C.
113 // https://unicode.org/reports/tr15/
114 if (!isNFC(map)) try normalization.ToNFC(map);
115
116 // 3. Break. Break the string into labels at U+002E ( . ) FULL STOP.
117 map.lengths.clearRetainingCapacity();
118 var it2 = std.mem.splitScalar(u8, map.list.items, '.');
119 while (it2.next()) |label| {
120 try map.lengths.append(map.allocator, label.len);
121 try map.lengths.append(map.allocator, 1);
122 }
123 _ = map.lengths.orderedRemove(map.lengths.items.len - 1);
124
125 // 4. Convert/Validate. For each label in the domain_name string:
126 for (0..map.lengths.items.len) |n| {
127 var label = map.items(n);
128 if (std.mem.eql(u8, label, ".")) continue;
129 if (std.mem.startsWith(u8, label, "xn--")) {
130 // 1. If the label contains any non-ASCII code point (i.e., a code point greater than U+007F), record that there was an error, and continue with the next label.
131 if (!extras.matchesAll(u8, label, std.ascii.isAscii)) return error.IDNAFailure;
132 // 2. Attempt to convert the rest of the label to Unicode according to Punycode [RFC3492]. If that conversion fails and if not IgnoreInvalidPunycode, record that there was an error, and continue with the next label. Otherwise replace the original label in the string by the results of the conversion.
133 punycode.decode(map, n) catch |err| switch (err) {
134 error.InvalidPunycode => if (!IgnoreInvalidPunycode) return error.IDNAFailure,
135 else => |e| return e,
136 };
137 label = map.items(n);
138 // 3. If the label is empty, or if the label contains only ASCII code points, record that there was an error.
139 if (label.len == 0) return error.IDNAFailure;
140 if (extras.matchesAll(u8, label, std.ascii.isAscii)) return error.IDNAFailure;
141 // 4. Verify that the label meets the validity criteria in Section 4.1, Validity Criteria for Nontransitional Processing. If any of the validity criteria are not satisfied, record that there was an error.
142 try Validity_Criteria(label, CheckHyphens, true, false, UseSTD3ASCIIRules, CheckJoiners, CheckBidi);
143 } else {
144 // 1. Verify that the label meets the validity criteria in Section 4.1, Validity Criteria for the input Processing choice (Transitional or Nontransitional). If any of the validity criteria are not satisfied, record that there was an error.
145 try Validity_Criteria(label, CheckHyphens, Transitional_Processing, !Transitional_Processing, UseSTD3ASCIIRules, CheckJoiners, CheckBidi);
146 }
147 }
148}
149
150//
151//
152//
153
154fn mappingRow(cp: u21) struct { table.Status, []const u21, table.Status2008 } {
155 if (std.sort.binarySearch(table.Row, &table.data, cp, extras.compareFnField(u21, table.Row, .cp))) |idx| {
156 const row = table.data[idx];
157 return .{ row.status, row.mapping, row.status2 };
158 }
159 if (std.sort.binarySearch(table.RowRange, &table.data_range, cp, extras.compareFnRange(u21, table.RowRange, .from, .to))) |idx| {
160 const row = table.data_range[idx];
161 return .{ row.status, row.mapping, row.status2 };
162 }
163 unreachable;
164}
165
166// TODO:
167fn isNFC(map: *const extras.ManyArrayList(u8)) bool {
168 _ = map;
169 return false;
170}
171
172fn Validity_Criteria(
173 label: []const u8,
174 CheckHyphens: bool,
175 Transitional_Processing: bool, //deprecated,
176 NonTransitional_Processing: bool, //deprecated,
177 UseSTD3ASCIIRules: bool,
178 CheckJoiners: bool,
179 CheckBidi: bool,
180) !void {
181 // if (!isNFC(label)) return error.IDNAFailure; // TODO:
182 if (CheckHyphens and label.len >= 4 and label[2] == '-' and label[3] == '-') return error.IDNAFailure;
183 if (CheckHyphens and std.mem.startsWith(u8, label, "-")) return error.IDNAFailure;
184 if (CheckHyphens and std.mem.endsWith(u8, label, "-")) return error.IDNAFailure;
185 if (!CheckHyphens and std.mem.startsWith(u8, label, "xn--")) return error.IDNAFailure;
186 if (std.mem.indexOfScalar(u8, label, '.') != null) return error.IDNAFailure;
187
188 _ = Transitional_Processing;
189 _ = NonTransitional_Processing;
190 _ = UseSTD3ASCIIRules;
191 _ = CheckJoiners;
192 _ = CheckBidi;
193}
licenses.txt+3
......@@ -1,3 +1,6 @@
11MIT:
22= https://spdx.org/licenses/MIT
33- This
4- git https://github.com/nektro/zig-expect
5- git https://github.com/nektro/zig-extras
6- git https://github.com/nektro/zig-unicode-ucd
normalization.zig created+238
......@@ -0,0 +1,238 @@
1const std = @import("std");
2const extras = @import("extras");
3const ucd = @import("unicode-ucd");
4
5const data = extras.StaticMultiList(ucd.unicode_data.Codepoint).initComptime(&ucd.unicode_data.data);
6const data_first_gap = blk: {
7 for (data.items[0], 0..) |cp, i| {
8 if (cp != i) {
9 break :blk i;
10 }
11 }
12};
13// comptime { @compileLog(data_first_gap); } // 888 as of 17.
14
15// hangul syllable constants
16const SBase = 0xAC00;
17const LBase = 0x1100;
18const VBase = 0x1161;
19const TBase = 0x11A7;
20const LCount = 19;
21const VCount = 21;
22const TCount = 28;
23const NCount = VCount * TCount;
24const SCount = LCount * NCount;
25
26pub fn ToNFD(map: *extras.ManyArrayList(u8)) !void {
27 try Decomposition(map, .canonical);
28}
29
30pub fn ToNFC(map: *extras.ManyArrayList(u8)) !void {
31 try ToNFD(map);
32 try CanonicalComposition(map);
33}
34
35pub fn ToNFKD(map: *extras.ManyArrayList(u8)) !void {
36 try Decomposition(map, .compatibility);
37}
38
39pub fn ToNFKC(map: *extras.ManyArrayList(u8)) !void {
40 try ToNFKD(map);
41 try CanonicalComposition(map);
42}
43
44fn Decomposition(map: *extras.ManyArrayList(u8), kind: enum { canonical, compatibility }) !void {
45 // fully decompose all codepoints in the string
46 var n: usize = 0;
47 while (n < map.lengths.items.len) : (n += 1) {
48 const sl = map.items(n);
49 const cp = std.unicode.utf8Decode(sl) catch unreachable;
50 if (std.sort.binarySearch(u21, data.items[0], cp, extras.compareFnBasic(u21))) |j| {
51 if (data.items[5][j] == .__none) continue;
52 if ((data.items[5][j] == .__canonical) != (kind == .canonical)) continue;
53 map.remove(n);
54 for (data.items[6][j], 0..) |ktem, k| {
55 var buf: [4]u8 = undefined;
56 const l = std.unicode.utf8Encode(ktem, &buf) catch unreachable;
57 try map.insertAt(n + k, buf[0..l]);
58 }
59 n += data.items[6][j].len - 1;
60 }
61 }
62 // sort non-starters with respect to canonical ordering
63 n = 0;
64 while (n < map.lengths.items.len) : (n += 1) {
65 const sln = map.items(n);
66 const cp = std.unicode.utf8Decode(sln) catch unreachable;
67 const ccc = cpCCC(cp);
68 if (ccc == 0) continue; // starter copdepoint
69 if (n == map.lengths.items.len - 1) break;
70 var buf: [128]u8 = @splat(0);
71 var len: u8 = 0;
72 buf[0] = ccc;
73 len += 1;
74 for (n + 1..map.lengths.items.len) |j| {
75 const slj = map.items(j);
76 const dp = std.unicode.utf8Decode(slj) catch unreachable;
77 const ddd = cpCCC(dp);
78 if (ddd == 0) break;
79 buf[len] = ddd;
80 len += 1;
81 }
82 const S = struct {
83 nstart: usize,
84 buf: []u8,
85 map: *extras.ManyArrayList(u8),
86
87 pub fn lessThan(self: *const @This(), a: usize, b: usize) bool {
88 return self.buf[a] < self.buf[b];
89 }
90 pub fn swap(self: *const @This(), a: usize, b: usize) void {
91 std.mem.swap(u8, &self.buf[a], &self.buf[b]);
92 self.map.swap(self.nstart + a, self.nstart + b);
93 }
94 };
95 std.mem.sortContext(0, len, S{
96 .nstart = n,
97 .buf = buf[0..len],
98 .map = map,
99 });
100 n += len;
101 }
102}
103
104fn CanonicalComposition(map: *extras.ManyArrayList(u8)) !void {
105 if (map.lengths.items.len < 2) {
106 return;
107 }
108
109 if (map.lengths.items.len == 2) {
110 const sll = map.items(0);
111 const l = std.unicode.utf8Decode(sll) catch unreachable;
112 const slc = map.items(1);
113 const c = std.unicode.utf8Decode(slc) catch unreachable;
114
115 for (&ucd.unicode_data.data) |d| {
116 if (d[5] != .__canonical) continue;
117 if (d[6].len != 2) continue;
118 if (d[6][0] != l) continue;
119 if (d[6][1] != c) continue;
120 if (std.sort.binarySearch(u21, &ucd.composition_exclusions.data, d[0], extras.compareFnBasic(u21)) != null) continue;
121 if (d[3] != 0) continue;
122
123 var buf: [4]u8 = undefined;
124 const len = std.unicode.utf8Encode(d[0], &buf) catch unreachable;
125 try map.set(0, buf[0..len]);
126 map.remove(1);
127 break;
128 }
129 return;
130 }
131
132 var i: usize = 1;
133 while (i < map.lengths.items.len) : (i += 1) {
134 const slc = map.items(i);
135 const c = std.unicode.utf8Decode(slc) catch unreachable;
136 var j: usize = i - 1;
137 var sll = map.items(j);
138 var l = std.unicode.utf8Decode(sll) catch unreachable;
139 while (j > 0) : (j -= 1) {
140 sll = map.items(j);
141 l = std.unicode.utf8Decode(sll) catch unreachable;
142 if (cpCCC(l) == 0) break;
143 }
144 for (&ucd.unicode_data.data) |d| {
145 if (d[5] != .__canonical) continue;
146 if (d[6].len != 2) continue;
147 if (d[6][0] != l) continue;
148 if (d[6][1] != c) continue;
149 if (std.sort.binarySearch(u21, &ucd.composition_exclusions.data, d[0], extras.compareFnBasic(u21)) != null) continue;
150 if (d[3] != 0) continue;
151
152 var buf: [4]u8 = undefined;
153 const len = std.unicode.utf8Encode(d[0], &buf) catch unreachable;
154 try map.set(j, buf[0..len]);
155 map.remove(i);
156 i -= 1;
157 break;
158 }
159 }
160 i = 0;
161 while (i < map.lengths.items.len) : (i += 1) {
162 const sll = map.items(i);
163 const cpl = std.unicode.utf8Decode(sll) catch unreachable;
164 if ((hangul_syllable_type(cpl) orelse continue) != .L) continue;
165 std.debug.assert(cpl >= 0x1100 and cpl <= 0x1112);
166
167 if (i + 1 == map.lengths.items.len) break;
168 const slv = map.items(i + 1);
169 const cpv = std.unicode.utf8Decode(slv) catch unreachable;
170 if ((hangul_syllable_type(cpv) orelse continue) != .V) continue;
171 std.debug.assert(cpv >= 0x1161 and cpv <= 0x1175);
172
173 if (i + 2 == map.lengths.items.len) {
174 //seq is only <L,V>
175 try composeHangulSyllable2(map, i, cpl, cpv);
176 continue;
177 }
178
179 const slt = map.items(i + 2);
180 const cpt = std.unicode.utf8Decode(slt) catch unreachable;
181 if ((hangul_syllable_type(cpt) orelse {
182 // try composeHangulSyllable2(map, i, cpl, cpv);
183 continue;
184 }) != .T) {
185 // try composeHangulSyllable2(map, i, cpl, cpv);
186 continue;
187 }
188 std.debug.assert(cpt >= 0x11A8 and cpt <= 0x11C2);
189 // seq is <L,V,T>
190 try composeHangulSyllable3(map, i, cpl, cpv, cpt);
191 }
192}
193
194fn cpCCC(cp: u21) u8 {
195 if (cp < data_first_gap) {
196 return data.items[3][cp];
197 }
198 if (std.sort.binarySearch(u21, data.items[0], cp, extras.compareFnBasic(u21))) |idx| {
199 return data.items[3][idx];
200 }
201 // TODO: this happens to be correct but ucd.unicode_data needs to detect the block ranges
202 return 0;
203}
204
205fn hangul_syllable_type(cp: u21) ?ucd.HangulSyllableType {
206 // can't use std.sort.binarySearch on this set because it's not sorted
207 // TODO: update ucd to have that property
208 for (&ucd.hangul_syllable_type.data) |d| {
209 if (cp >= d.from and cp <= d.to) {
210 return d.prop;
211 }
212 }
213 return null;
214}
215
216fn composeHangulSyllable2(map: *extras.ManyArrayList(u8), i: usize, cpl: u21, cpv: u21) !void {
217 const LIndex = cpl - LBase;
218 const VIndex = cpv - VBase;
219 const LVIndex = LIndex * NCount + VIndex * TCount;
220 const cps = SBase + LVIndex;
221 var buf: [4]u8 = undefined;
222 const len = std.unicode.utf8Encode(cps, &buf) catch unreachable;
223 try map.set(i, buf[0..len]);
224 map.remove(i + 1);
225}
226
227fn composeHangulSyllable3(map: *extras.ManyArrayList(u8), i: usize, cpl: u21, cpv: u21, cpt: u21) !void {
228 const LIndex = cpl - LBase;
229 const VIndex = cpv - VBase;
230 const TIndex = cpt - TBase;
231 const LVIndex = LIndex * NCount + VIndex * TCount;
232 const cps = SBase + LVIndex + TIndex;
233 var buf: [4]u8 = undefined;
234 const len = std.unicode.utf8Encode(cps, &buf) catch unreachable;
235 try map.set(i, buf[0..len]);
236 map.remove(i + 1);
237 map.remove(i + 1);
238}
punycode.zig created+137
......@@ -0,0 +1,137 @@
1const std = @import("std");
2const extras = @import("extras");
3
4const base = 36;
5const tmin = 1;
6const tmax = 26;
7const skew = 38;
8const damp = 700;
9const initial_bias = 72;
10const initial_n = 128;
11const delimiter = '-';
12
13pub fn decode(map: *extras.ManyArrayList(u8), map_n: usize) !void {
14 var input = map.items(map_n);
15 var offset: usize = 0;
16 const initial_len = input.len;
17 // std.debug.assert(std.mem.startsWith(u8, map.items(n), "xn--"));
18 offset += 4;
19 input = input[offset..initial_len];
20
21 var word_n: u32 = 0;
22 word_n += initial_n;
23
24 // let n = initial_n
25 var n: u21 = 128;
26 // let i = 0
27 var i: u32 = 0;
28 // let bias = initial_bias
29 var bias: u32 = initial_bias;
30 // let output = an empty string indexed from 0
31 // output is ascii so output_length as codepoint or bytes is the same
32 var output_length: u32 = 0;
33 // consume all code points before the last delimiter (if there is one) and copy them to output, fail on any non-basic code point
34 // if more than zero code points were consumed then consume one more (which will be the last delimiter)
35 if (std.mem.lastIndexOfScalar(u8, input, delimiter)) |idx| {
36 // we're passing input as what we're appending so we have to ensure the backing allocation is not invalidated by calling append
37 try map.list.ensureUnusedCapacity(map.allocator, idx);
38 input = map.items(map_n)[offset..initial_len];
39 try map.appendSlice(map_n, input[0..idx]);
40 offset += idx + 1;
41 input = input[idx + 1 ..];
42 output_length += @intCast(idx);
43 }
44 // while the input is not exhausted do begin
45 while (offset < initial_len) {
46 // let oldi = i
47 const oldi = i;
48 // let w = 1
49 var w: u32 = 1;
50 // for k = base to infinity in steps of base do begin
51 var k: u32 = base;
52 while (true) : (k += base) {
53 // consume a code point, or fail if there was none to consume
54 if (input.len == 0) return error.InvalidPunycode;
55 const sl = input[0 .. std.unicode.utf8ByteSequenceLength(input[0]) catch unreachable];
56 offset += sl.len;
57 input = input[sl.len..];
58 // let digit = the code point's digit-value, fail if it has none
59 const cp = std.unicode.utf8Decode(sl) catch unreachable;
60 const digit: u32 = blk: {
61 if (cp >= 'A' and cp <= 'Z') break :blk cp - 'A';
62 if (cp >= 'a' and cp <= 'z') break :blk cp - 'a';
63 if (cp >= '0' and cp <= '9') break :blk cp - '0' + 26;
64 return error.InvalidPunycode;
65 };
66 // let i = i + digit * w, fail on overflow
67 i = std.math.add(u32, i, std.math.mul(u32, digit, w) catch return error.InvalidPunycode) catch return error.InvalidPunycode;
68 // let t = tmin if k <= bias {+ tmin}, or
69 // tmax if k >= bias + tmax, or k - bias otherwise
70 const t = if (k <= bias) tmin else if (k >= bias + tmax) tmax else k - bias;
71 // if digit < t then break
72 if (digit < t) break;
73 // let w = w * (base - t), fail on overflow
74 w = w * (base - t);
75 }
76 // let bias = adapt(i - oldi, length(output) + 1, test oldi is 0?)
77 bias = adapt(i - oldi, output_length + 1, oldi == 0);
78 // let n = n + i div (length(output) + 1), fail on overflow
79 n = std.math.add(u21, n, @intCast(i / (output_length + 1))) catch return error.InvalidPunycode;
80 // let i = i mod (length(output) + 1)
81 i = i % (output_length + 1);
82 // {if n is a basic code point then fail}
83 std.debug.assert(n > std.math.maxInt(u7));
84 // insert n into output at position i
85 if (i == output_length) {
86 var buf: [4]u8 = undefined;
87 const len = std.unicode.utf8Encode(n, &buf) catch unreachable;
88 try map.appendSlice(map_n, buf[0..len]);
89 input = map.items(map_n)[offset..initial_len];
90 output_length += 1;
91 } else {
92 var ioff: usize = 0;
93 var cpi: usize = 0;
94 var it = std.unicode.Utf8View.initUnchecked(map.items(map_n)[initial_len..]).iterator();
95 while (it.nextCodepointSlice()) |sl| {
96 if (cpi == i) break;
97 ioff += sl.len;
98 cpi += 1;
99 }
100 var buf: [4]u8 = undefined;
101 const len = std.unicode.utf8Encode(n, &buf) catch unreachable;
102 try map.replace(map_n, initial_len + ioff, 0, buf[0..len]);
103 input = map.items(map_n)[offset..initial_len];
104 output_length += 1;
105 }
106 // increment i
107 i += 1;
108 }
109
110 try map.replace(map_n, 0, initial_len, "");
111}
112
113fn adapt(delta_: u32, numpoints: u32, firsttime: bool) u32 {
114 var delta = delta_;
115 // if firsttime then let delta = delta div damp
116 // else let delta = delta div 2
117 delta = if (firsttime) delta / damp else delta / 2;
118 // let delta = delta + (delta div numpoints)
119 delta = delta + (delta / numpoints);
120 // let k = 0
121 var k: u32 = 0;
122 // while delta > ((base - tmin) * tmax) div 2 do begin
123 while (delta > ((base - tmin) * tmax) / 2) {
124 // let delta = delta div (base - tmin)
125 delta /= base - tmin;
126 // let k = k + base
127 k += base;
128 }
129 // return k + (((base - tmin + 1) * delta) div (delta + skew))
130 return k + (((base - tmin + 1) * delta) / (delta + skew));
131}
132
133// TODO:
134pub fn encode(map: *extras.ManyArrayList(u8), n: usize) !void {
135 _ = map;
136 _ = n;
137}
testv2.zig+712
......@@ -4,4 +4,716 @@
44
55// Based on the source file: https://www.unicode.org/Public/17.0.0/idna/IdnaTestV2.txt
66//
7// zig fmt: off
78
9const std = @import("std");
10const idna = @import("unicode-idna");
11const expect = @import("expect").expect;
12
13fn toUnicodePass(
14 source: []const u8,
15 expected: []const u8,
16) !void {
17 const allocator = std.testing.allocator;
18 const result = try idna.ToUnicode(allocator, source, true, true, true, true, false, false);
19 defer allocator.free(result);
20 try expect(result).toEqualString(expected);
21}
22
23fn toUnicodeFail(
24 source: []const u8,
25) !void {
26 const allocator = std.testing.allocator;
27 const result = idna.ToUnicode(allocator, source, true, true, true, true, false, false) catch |err| switch (err) {
28 error.IDNAFailure => return,
29 error.OutOfMemory => return error.OutOfMemory,
30 };
31 defer allocator.free(result);
32 return error.ShouldHaveFailed;
33}
34
35fn toAsciiPass(
36 source: []const u8,
37 expected: []const u8,
38 Transitional_Processing: bool,
39) !void {
40 const allocator = std.testing.allocator;
41 const result = try idna.ToASCII(allocator, source, true, true, true, true, Transitional_Processing, true, false);
42 defer allocator.free(result);
43 try expect(result).toEqualString(expected);
44}
45
46fn toAsciiFail(
47 source: []const u8,
48 Transitional_Processing: bool,
49) !void {
50 const allocator = std.testing.allocator;
51 const result = idna.ToASCII(allocator, source, true, true, true, true, Transitional_Processing, true, false) catch |err| switch (err) {
52 error.IDNAFailure => return,
53 error.OutOfMemory => return error.OutOfMemory,
54 };
55 defer allocator.free(result);
56 return error.ShouldHaveFailed;
57}
58
59test { try toUnicodePass("fass.de", "fass.de"); }
60test { try toUnicodePass("fa\xc3\x9f.de", "fa\xc3\x9f.de"); }
61test { try toUnicodePass("Fa\xc3\x9f.de", "fa\xc3\x9f.de"); }
62test { try toUnicodePass("xn--fa-hia.de", "fa\xc3\x9f.de"); }
63test { try toUnicodePass("\xc3\xa0.\xd7\x90\xcc\x88", "\xc3\xa0.\xd7\x90\xcc\x88"); }
64test { try toUnicodePass("a\xcc\x80.\xd7\x90\xcc\x88", "\xc3\xa0.\xd7\x90\xcc\x88"); }
65test { try toUnicodePass("A\xcc\x80.\xd7\x90\xcc\x88", "\xc3\xa0.\xd7\x90\xcc\x88"); }
66test { try toUnicodePass("\xc3\x80.\xd7\x90\xcc\x88", "\xc3\xa0.\xd7\x90\xcc\x88"); }
67test { try toUnicodePass("xn--0ca.xn--ssa73l", "\xc3\xa0.\xd7\x90\xcc\x88"); }
68test { try toUnicodePass("\xc3\xa0\xcc\x88.\xd7\x90", "\xc3\xa0\xcc\x88.\xd7\x90"); }
69test { try toUnicodePass("a\xcc\x80\xcc\x88.\xd7\x90", "\xc3\xa0\xcc\x88.\xd7\x90"); }
70test { try toUnicodePass("A\xcc\x80\xcc\x88.\xd7\x90", "\xc3\xa0\xcc\x88.\xd7\x90"); }
71test { try toUnicodePass("\xc3\x80\xcc\x88.\xd7\x90", "\xc3\xa0\xcc\x88.\xd7\x90"); }
72test { try toUnicodePass("xn--0ca81i.xn--4db", "\xc3\xa0\xcc\x88.\xd7\x90"); }
73test { try toUnicodePass("ab", "ab"); }
74test { try toUnicodePass("a\xe0\xa5\x8d\xe2\x80\x8cb", "a\xe0\xa5\x8d\xe2\x80\x8cb"); }
75test { try toUnicodePass("A\xe0\xa5\x8d\xe2\x80\x8cB", "a\xe0\xa5\x8d\xe2\x80\x8cb"); }
76test { try toUnicodePass("A\xe0\xa5\x8d\xe2\x80\x8cb", "a\xe0\xa5\x8d\xe2\x80\x8cb"); }
77test { try toUnicodePass("xn--ab-fsf", "a\xe0\xa5\x8db"); }
78test { try toUnicodePass("a\xe0\xa5\x8db", "a\xe0\xa5\x8db"); }
79test { try toUnicodePass("A\xe0\xa5\x8dB", "a\xe0\xa5\x8db"); }
80test { try toUnicodePass("A\xe0\xa5\x8db", "a\xe0\xa5\x8db"); }
81test { try toUnicodePass("xn--ab-fsf604u", "a\xe0\xa5\x8d\xe2\x80\x8cb"); }
82test { try toUnicodePass("a\xe0\xa5\x8d\xe2\x80\x8db", "a\xe0\xa5\x8d\xe2\x80\x8db"); }
83test { try toUnicodePass("A\xe0\xa5\x8d\xe2\x80\x8dB", "a\xe0\xa5\x8d\xe2\x80\x8db"); }
84test { try toUnicodePass("A\xe0\xa5\x8d\xe2\x80\x8db", "a\xe0\xa5\x8d\xe2\x80\x8db"); }
85test { try toUnicodePass("xn--ab-fsf014u", "a\xe0\xa5\x8d\xe2\x80\x8db"); }
86test { try toUnicodePass("\xc2\xa1", "\xc2\xa1"); }
87test { try toUnicodePass("xn--7a", "\xc2\xa1"); }
88test { try toUnicodePass("\xe1\xa7\x9a", "\xe1\xa7\x9a"); }
89test { try toUnicodePass("xn--pkf", "\xe1\xa7\x9a"); }
90test { try toUnicodePass("\xea\xad\xa0", "\xea\xad\xa0"); }
91test { try toUnicodePass("xn--3y9a", "\xea\xad\xa0"); }
92test { try toUnicodePass("1234567890\xc3\xa41234567890123456789012345678901234567890123456", "1234567890\xc3\xa41234567890123456789012345678901234567890123456"); }
93test { try toUnicodePass("1234567890a\xcc\x881234567890123456789012345678901234567890123456", "1234567890\xc3\xa41234567890123456789012345678901234567890123456"); }
94test { try toUnicodePass("1234567890A\xcc\x881234567890123456789012345678901234567890123456", "1234567890\xc3\xa41234567890123456789012345678901234567890123456"); }
95test { try toUnicodePass("1234567890\xc3\x841234567890123456789012345678901234567890123456", "1234567890\xc3\xa41234567890123456789012345678901234567890123456"); }
96test { try toUnicodePass("xn--12345678901234567890123456789012345678901234567890123456-fxe", "1234567890\xc3\xa41234567890123456789012345678901234567890123456"); }
97test { try toUnicodePass("www.eXample.cOm", "www.example.com"); }
98test { try toUnicodePass("B\xc3\xbccher.de", "b\xc3\xbccher.de"); }
99test { try toUnicodePass("Bu\xcc\x88cher.de", "b\xc3\xbccher.de"); }
100test { try toUnicodePass("bu\xcc\x88cher.de", "b\xc3\xbccher.de"); }
101test { try toUnicodePass("b\xc3\xbccher.de", "b\xc3\xbccher.de"); }
102test { try toUnicodePass("B\xc3\x9cCHER.DE", "b\xc3\xbccher.de"); }
103test { try toUnicodePass("BU\xcc\x88CHER.DE", "b\xc3\xbccher.de"); }
104test { try toUnicodePass("xn--bcher-kva.de", "b\xc3\xbccher.de"); }
105test { try toUnicodePass("\xc3\x96BB", "\xc3\xb6bb"); }
106test { try toUnicodePass("O\xcc\x88BB", "\xc3\xb6bb"); }
107test { try toUnicodePass("o\xcc\x88bb", "\xc3\xb6bb"); }
108test { try toUnicodePass("\xc3\xb6bb", "\xc3\xb6bb"); }
109test { try toUnicodePass("\xc3\x96bb", "\xc3\xb6bb"); }
110test { try toUnicodePass("O\xcc\x88bb", "\xc3\xb6bb"); }
111test { try toUnicodePass("xn--bb-eka", "\xc3\xb6bb"); }
112test { try toUnicodePass("FA\xe1\xba\x9e.de", "fa\xc3\x9f.de"); }
113test { try toUnicodePass("FA\xe1\xba\x9e.DE", "fa\xc3\x9f.de"); }
114test { try toUnicodePass("\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x82.com", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x82.com"); }
115test { try toUnicodePass("\xce\xb2\xce\xbf\xcc\x81\xce\xbb\xce\xbf\xcf\x82.com", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x82.com"); }
116test { try toUnicodePass("\xce\x92\xce\x9f\xcc\x81\xce\x9b\xce\x9f\xce\xa3.COM", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83.com"); }
117test { try toUnicodePass("\xce\x92\xce\x8c\xce\x9b\xce\x9f\xce\xa3.COM", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83.com"); }
118test { try toUnicodePass("\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83.com", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83.com"); }
119test { try toUnicodePass("\xce\xb2\xce\xbf\xcc\x81\xce\xbb\xce\xbf\xcf\x83.com", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83.com"); }
120test { try toUnicodePass("\xce\x92\xce\xbf\xcc\x81\xce\xbb\xce\xbf\xcf\x83.com", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83.com"); }
121test { try toUnicodePass("\xce\x92\xcf\x8c\xce\xbb\xce\xbf\xcf\x83.com", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83.com"); }
122test { try toUnicodePass("xn--nxasmq6b.com", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83.com"); }
123test { try toUnicodePass("\xce\x92\xce\xbf\xcc\x81\xce\xbb\xce\xbf\xcf\x82.com", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x82.com"); }
124test { try toUnicodePass("\xce\x92\xcf\x8c\xce\xbb\xce\xbf\xcf\x82.com", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x82.com"); }
125test { try toUnicodePass("xn--nxasmm1c.com", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x82.com"); }
126test { try toUnicodePass("xn--nxasmm1c", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x82"); }
127test { try toUnicodePass("\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x82", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x82"); }
128test { try toUnicodePass("\xce\xb2\xce\xbf\xcc\x81\xce\xbb\xce\xbf\xcf\x82", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x82"); }
129test { try toUnicodePass("\xce\x92\xce\x9f\xcc\x81\xce\x9b\xce\x9f\xce\xa3", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83"); }
130test { try toUnicodePass("\xce\x92\xce\x8c\xce\x9b\xce\x9f\xce\xa3", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83"); }
131test { try toUnicodePass("\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83"); }
132test { try toUnicodePass("\xce\xb2\xce\xbf\xcc\x81\xce\xbb\xce\xbf\xcf\x83", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83"); }
133test { try toUnicodePass("\xce\x92\xce\xbf\xcc\x81\xce\xbb\xce\xbf\xcf\x83", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83"); }
134test { try toUnicodePass("\xce\x92\xcf\x8c\xce\xbb\xce\xbf\xcf\x83", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83"); }
135test { try toUnicodePass("xn--nxasmq6b", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x83"); }
136test { try toUnicodePass("\xce\x92\xcf\x8c\xce\xbb\xce\xbf\xcf\x82", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x82"); }
137test { try toUnicodePass("\xce\x92\xce\xbf\xcc\x81\xce\xbb\xce\xbf\xcf\x82", "\xce\xb2\xcf\x8c\xce\xbb\xce\xbf\xcf\x82"); }
138test { try toUnicodePass("www.\xe0\xb7\x81\xe0\xb7\x8a\xe2\x80\x8d\xe0\xb6\xbb\xe0\xb7\x93.com", "www.\xe0\xb7\x81\xe0\xb7\x8a\xe2\x80\x8d\xe0\xb6\xbb\xe0\xb7\x93.com"); }
139test { try toUnicodePass("WWW.\xe0\xb7\x81\xe0\xb7\x8a\xe2\x80\x8d\xe0\xb6\xbb\xe0\xb7\x93.COM", "www.\xe0\xb7\x81\xe0\xb7\x8a\xe2\x80\x8d\xe0\xb6\xbb\xe0\xb7\x93.com"); }
140test { try toUnicodePass("Www.\xe0\xb7\x81\xe0\xb7\x8a\xe2\x80\x8d\xe0\xb6\xbb\xe0\xb7\x93.com", "www.\xe0\xb7\x81\xe0\xb7\x8a\xe2\x80\x8d\xe0\xb6\xbb\xe0\xb7\x93.com"); }
141test { try toUnicodePass("www.xn--10cl1a0b.com", "www.\xe0\xb7\x81\xe0\xb7\x8a\xe0\xb6\xbb\xe0\xb7\x93.com"); }
142test { try toUnicodePass("www.\xe0\xb7\x81\xe0\xb7\x8a\xe0\xb6\xbb\xe0\xb7\x93.com", "www.\xe0\xb7\x81\xe0\xb7\x8a\xe0\xb6\xbb\xe0\xb7\x93.com"); }
143test { try toUnicodePass("WWW.\xe0\xb7\x81\xe0\xb7\x8a\xe0\xb6\xbb\xe0\xb7\x93.COM", "www.\xe0\xb7\x81\xe0\xb7\x8a\xe0\xb6\xbb\xe0\xb7\x93.com"); }
144test { try toUnicodePass("Www.\xe0\xb7\x81\xe0\xb7\x8a\xe0\xb6\xbb\xe0\xb7\x93.com", "www.\xe0\xb7\x81\xe0\xb7\x8a\xe0\xb6\xbb\xe0\xb7\x93.com"); }
145test { try toUnicodePass("www.xn--10cl1a0b660p.com", "www.\xe0\xb7\x81\xe0\xb7\x8a\xe2\x80\x8d\xe0\xb6\xbb\xe0\xb7\x93.com"); }
146test { try toUnicodePass("\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xe2\x80\x8c\xd8\xa7\xdb\x8c", "\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xe2\x80\x8c\xd8\xa7\xdb\x8c"); }
147test { try toUnicodePass("xn--mgba3gch31f", "\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xd8\xa7\xdb\x8c"); }
148test { try toUnicodePass("\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xd8\xa7\xdb\x8c", "\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xd8\xa7\xdb\x8c"); }
149test { try toUnicodePass("xn--mgba3gch31f060k", "\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xe2\x80\x8c\xd8\xa7\xdb\x8c"); }
150test { try toUnicodePass("xn--mgba3gch31f060k.com", "\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xe2\x80\x8c\xd8\xa7\xdb\x8c.com"); }
151test { try toUnicodePass("\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xe2\x80\x8c\xd8\xa7\xdb\x8c.com", "\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xe2\x80\x8c\xd8\xa7\xdb\x8c.com"); }
152test { try toUnicodePass("\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xe2\x80\x8c\xd8\xa7\xdb\x8c.COM", "\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xe2\x80\x8c\xd8\xa7\xdb\x8c.com"); }
153test { try toUnicodePass("xn--mgba3gch31f.com", "\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xd8\xa7\xdb\x8c.com"); }
154test { try toUnicodePass("\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xd8\xa7\xdb\x8c.com", "\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xd8\xa7\xdb\x8c.com"); }
155test { try toUnicodePass("\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xd8\xa7\xdb\x8c.COM", "\xd9\x86\xd8\xa7\xd9\x85\xd9\x87\xd8\xa7\xdb\x8c.com"); }
156test { try toUnicodePass("a.b\xef\xbc\x8ec\xe3\x80\x82d\xef\xbd\xa1", "a.b.c.d."); }
157test { try toUnicodePass("a.b.c\xe3\x80\x82d\xe3\x80\x82", "a.b.c.d."); }
158test { try toUnicodePass("A.B.C\xe3\x80\x82D\xe3\x80\x82", "a.b.c.d."); }
159test { try toUnicodePass("A.b.c\xe3\x80\x82D\xe3\x80\x82", "a.b.c.d."); }
160test { try toUnicodePass("a.b.c.d.", "a.b.c.d."); }
161test { try toUnicodePass("A.B\xef\xbc\x8eC\xe3\x80\x82D\xef\xbd\xa1", "a.b.c.d."); }
162test { try toUnicodePass("A.b\xef\xbc\x8ec\xe3\x80\x82D\xef\xbd\xa1", "a.b.c.d."); }
163test { try toUnicodePass("U\xcc\x88.xn--tda", "\xc3\xbc.\xc3\xbc"); }
164test { try toUnicodePass("\xc3\x9c.xn--tda", "\xc3\xbc.\xc3\xbc"); }
165test { try toUnicodePass("\xc3\xbc.xn--tda", "\xc3\xbc.\xc3\xbc"); }
166test { try toUnicodePass("u\xcc\x88.xn--tda", "\xc3\xbc.\xc3\xbc"); }
167test { try toUnicodePass("U\xcc\x88.XN--TDA", "\xc3\xbc.\xc3\xbc"); }
168test { try toUnicodePass("\xc3\x9c.XN--TDA", "\xc3\xbc.\xc3\xbc"); }
169test { try toUnicodePass("\xc3\x9c.xn--Tda", "\xc3\xbc.\xc3\xbc"); }
170test { try toUnicodePass("U\xcc\x88.xn--Tda", "\xc3\xbc.\xc3\xbc"); }
171test { try toUnicodePass("xn--tda.xn--tda", "\xc3\xbc.\xc3\xbc"); }
172test { try toUnicodePass("\xc3\xbc.\xc3\xbc", "\xc3\xbc.\xc3\xbc"); }
173test { try toUnicodePass("u\xcc\x88.u\xcc\x88", "\xc3\xbc.\xc3\xbc"); }
174test { try toUnicodePass("U\xcc\x88.U\xcc\x88", "\xc3\xbc.\xc3\xbc"); }
175test { try toUnicodePass("\xc3\x9c.\xc3\x9c", "\xc3\xbc.\xc3\xbc"); }
176test { try toUnicodePass("\xc3\x9c.\xc3\xbc", "\xc3\xbc.\xc3\xbc"); }
177test { try toUnicodePass("U\xcc\x88.u\xcc\x88", "\xc3\xbc.\xc3\xbc"); }
178test { try toUnicodePass("a1.com", "a1.com"); }
179test { try toUnicodePass("\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e\xe3\x80\x82\xef\xbc\xaa\xef\xbc\xb0", "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e.jp"); }
180test { try toUnicodePass("\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e\xe3\x80\x82JP", "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e.jp"); }
181test { try toUnicodePass("\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e\xe3\x80\x82jp", "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e.jp"); }
182test { try toUnicodePass("\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e\xe3\x80\x82Jp", "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e.jp"); }
183test { try toUnicodePass("xn--wgv71a119e.jp", "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e.jp"); }
184test { try toUnicodePass("\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e.jp", "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e.jp"); }
185test { try toUnicodePass("\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e.JP", "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e.jp"); }
186test { try toUnicodePass("\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e.Jp", "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e.jp"); }
187test { try toUnicodePass("\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e\xe3\x80\x82\xef\xbd\x8a\xef\xbd\x90", "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e.jp"); }
188test { try toUnicodePass("\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e\xe3\x80\x82\xef\xbc\xaa\xef\xbd\x90", "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e.jp"); }
189test { try toUnicodePass("\xe2\x98\x95", "\xe2\x98\x95"); }
190test { try toUnicodePass("xn--53h", "\xe2\x98\x95"); }
191test { try toUnicodePass("1.xn--assbcssssssssdssssssssssssssssessssssssssssssssssssxssssssssssssssssssssysssssssssssssssssz-pxq1419aa", "1.assbcssssssssd\xcf\x83\xcf\x83ssssssssssssssssessssssssssssssssssssxssssssssssssssssssssysssssssssssssss\xc5\x9dssz"); }
192test { try toUnicodePass("1.assbcssssssssd\xcf\x83\xcf\x83ssssssssssssssssessssssssssssssssssssxssssssssssssssssssssysssssssssssssss\xc5\x9dssz", "1.assbcssssssssd\xcf\x83\xcf\x83ssssssssssssssssessssssssssssssssssssxssssssssssssssssssssysssssssssssssss\xc5\x9dssz"); }
193test { try toUnicodePass("1.assbcssssssssd\xcf\x83\xcf\x83ssssssssssssssssessssssssssssssssssssxssssssssssssssssssssyssssssssssssssss\xcc\x82ssz", "1.assbcssssssssd\xcf\x83\xcf\x83ssssssssssssssssessssssssssssssssssssxssssssssssssssssssssysssssssssssssss\xc5\x9dssz"); }
194test { try toUnicodePass("1.ASSBCSSSSSSSSD\xce\xa3\xce\xa3SSSSSSSSSSSSSSSSESSSSSSSSSSSSSSSSSSSSXSSSSSSSSSSSSSSSSSSSSYSSSSSSSSSSSSSSSS\xcc\x82SSZ", "1.assbcssssssssd\xcf\x83\xcf\x83ssssssssssssssssessssssssssssssssssssxssssssssssssssssssssysssssssssssssss\xc5\x9dssz"); }
195test { try toUnicodePass("1.ASSBCSSSSSSSSD\xce\xa3\xce\xa3SSSSSSSSSSSSSSSSESSSSSSSSSSSSSSSSSSSSXSSSSSSSSSSSSSSSSSSSSYSSSSSSSSSSSSSSS\xc5\x9cSSZ", "1.assbcssssssssd\xcf\x83\xcf\x83ssssssssssssssssessssssssssssssssssssxssssssssssssssssssssysssssssssssssss\xc5\x9dssz"); }
196test { try toUnicodePass("1.Assbcssssssssd\xcf\x83\xcf\x83ssssssssssssssssessssssssssssssssssssxssssssssssssssssssssysssssssssssssss\xc5\x9dssz", "1.assbcssssssssd\xcf\x83\xcf\x83ssssssssssssssssessssssssssssssssssssxssssssssssssssssssssysssssssssssssss\xc5\x9dssz"); }
197test { try toUnicodePass("1.Assbcssssssssd\xcf\x83\xcf\x83ssssssssssssssssessssssssssssssssssssxssssssssssssssssssssyssssssssssssssss\xcc\x82ssz", "1.assbcssssssssd\xcf\x83\xcf\x83ssssssssssssssssessssssssssssssssssssxssssssssssssssssssssysssssssssssssss\xc5\x9dssz"); }
198test { try toUnicodePass("xn--bss", "\xe5\xa4\x99"); }
199test { try toUnicodePass("\xe5\xa4\x99", "\xe5\xa4\x99"); }
200test { try toUnicodePass("\xcb\xa3\xcd\x8f\xe2\x84\x95\xe2\x80\x8b\xef\xb9\xa3\xc2\xad\xef\xbc\x8d\xe1\xa0\x8c\xe2\x84\xac\xef\xb8\x80\xc5\xbf\xe2\x81\xa4\xf0\x9d\x94\xb0\xf3\xa0\x87\xaf\xef\xac\x84", "\xe5\xa4\xa1\xe5\xa4\x9e\xe5\xa4\x9c\xe5\xa4\x99"); }
201test { try toUnicodePass("x\xcd\x8fN\xe2\x80\x8b-\xc2\xad-\xe1\xa0\x8cB\xef\xb8\x80s\xe2\x81\xa4s\xf3\xa0\x87\xafffl", "\xe5\xa4\xa1\xe5\xa4\x9e\xe5\xa4\x9c\xe5\xa4\x99"); }
202test { try toUnicodePass("x\xcd\x8fn\xe2\x80\x8b-\xc2\xad-\xe1\xa0\x8cb\xef\xb8\x80s\xe2\x81\xa4s\xf3\xa0\x87\xafffl", "\xe5\xa4\xa1\xe5\xa4\x9e\xe5\xa4\x9c\xe5\xa4\x99"); }
203test { try toUnicodePass("X\xcd\x8fN\xe2\x80\x8b-\xc2\xad-\xe1\xa0\x8cB\xef\xb8\x80S\xe2\x81\xa4S\xf3\xa0\x87\xafFFL", "\xe5\xa4\xa1\xe5\xa4\x9e\xe5\xa4\x9c\xe5\xa4\x99"); }
204test { try toUnicodePass("X\xcd\x8fn\xe2\x80\x8b-\xc2\xad-\xe1\xa0\x8cB\xef\xb8\x80s\xe2\x81\xa4s\xf3\xa0\x87\xafffl", "\xe5\xa4\xa1\xe5\xa4\x9e\xe5\xa4\x9c\xe5\xa4\x99"); }
205test { try toUnicodePass("xn--bssffl", "\xe5\xa4\xa1\xe5\xa4\x9e\xe5\xa4\x9c\xe5\xa4\x99"); }
206test { try toUnicodePass("\xe5\xa4\xa1\xe5\xa4\x9e\xe5\xa4\x9c\xe5\xa4\x99", "\xe5\xa4\xa1\xe5\xa4\x9e\xe5\xa4\x9c\xe5\xa4\x99"); }
207test { try toUnicodePass("\xcb\xa3\xcd\x8f\xe2\x84\x95\xe2\x80\x8b\xef\xb9\xa3\xc2\xad\xef\xbc\x8d\xe1\xa0\x8c\xe2\x84\xac\xef\xb8\x80S\xe2\x81\xa4\xf0\x9d\x94\xb0\xf3\xa0\x87\xafFFL", "\xe5\xa4\xa1\xe5\xa4\x9e\xe5\xa4\x9c\xe5\xa4\x99"); }
208test { try toUnicodePass("x\xcd\x8fN\xe2\x80\x8b-\xc2\xad-\xe1\xa0\x8cB\xef\xb8\x80S\xe2\x81\xa4s\xf3\xa0\x87\xafFFL", "\xe5\xa4\xa1\xe5\xa4\x9e\xe5\xa4\x9c\xe5\xa4\x99"); }
209test { try toUnicodePass("\xcb\xa3\xcd\x8f\xe2\x84\x95\xe2\x80\x8b\xef\xb9\xa3\xc2\xad\xef\xbc\x8d\xe1\xa0\x8c\xe2\x84\xac\xef\xb8\x80s\xe2\x81\xa4\xf0\x9d\x94\xb0\xf3\xa0\x87\xafffl", "\xe5\xa4\xa1\xe5\xa4\x9e\xe5\xa4\x9c\xe5\xa4\x99"); }
210test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b", "123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
211test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b.", "123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b."); }
212test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901c", "123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901c"); }
213test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901234.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a", "123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901234.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a"); }
214test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901234.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a.", "123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901234.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a."); }
215test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901234.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b", "123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901234.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
216test { try toUnicodePass("\xc3\xa41234567890123456789012345678901234567890123456789012345", "\xc3\xa41234567890123456789012345678901234567890123456789012345"); }
217test { try toUnicodePass("a\xcc\x881234567890123456789012345678901234567890123456789012345", "\xc3\xa41234567890123456789012345678901234567890123456789012345"); }
218test { try toUnicodePass("A\xcc\x881234567890123456789012345678901234567890123456789012345", "\xc3\xa41234567890123456789012345678901234567890123456789012345"); }
219test { try toUnicodePass("\xc3\x841234567890123456789012345678901234567890123456789012345", "\xc3\xa41234567890123456789012345678901234567890123456789012345"); }
220test { try toUnicodePass("xn--1234567890123456789012345678901234567890123456789012345-9te", "\xc3\xa41234567890123456789012345678901234567890123456789012345"); }
221test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
222test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890a\xcc\x88123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
223test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890A\xcc\x88123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890B", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
224test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\x84123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890B", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
225test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.xn--1234567890123456789012345678901234567890123456789012345-kue.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
226test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b.", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b."); }
227test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890a\xcc\x88123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b.", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b."); }
228test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890A\xcc\x88123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890B.", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b."); }
229test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\x84123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890B.", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b."); }
230test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.xn--1234567890123456789012345678901234567890123456789012345-kue.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b.", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b."); }
231test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901c", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901c"); }
232test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890a\xcc\x88123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901c", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901c"); }
233test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890A\xcc\x88123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901C", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901c"); }
234test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\x84123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901C", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901c"); }
235test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.xn--1234567890123456789012345678901234567890123456789012345-kue.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901c", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901c"); }
236test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a"); }
237test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890a\xcc\x881234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a"); }
238test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890A\xcc\x881234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789A", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a"); }
239test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\x841234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789A", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a"); }
240test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.xn--12345678901234567890123456789012345678901234567890123456-fxe.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a"); }
241test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a.", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a."); }
242test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890a\xcc\x881234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a.", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a."); }
243test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890A\xcc\x881234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789A.", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a."); }
244test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\x841234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789A.", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a."); }
245test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.xn--12345678901234567890123456789012345678901234567890123456-fxe.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a.", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a."); }
246test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
247test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890a\xcc\x881234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
248test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890A\xcc\x881234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890B", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
249test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\x841234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890B", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
250test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.xn--12345678901234567890123456789012345678901234567890123456-fxe.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
251test { try toUnicodePass("A0", "a0"); }
252test { try toUnicodePass("0A", "0a"); }
253test { try toUnicodePass("\xd7\x90\xd7\x87", "\xd7\x90\xd7\x87"); }
254test { try toUnicodePass("xn--vdbr", "\xd7\x90\xd7\x87"); }
255test { try toUnicodePass("\xd7\x909\xd7\x87", "\xd7\x909\xd7\x87"); }
256test { try toUnicodePass("xn--9-ihcz", "\xd7\x909\xd7\x87"); }
257test { try toUnicodePass("\xd7\x90\xd7\xaa", "\xd7\x90\xd7\xaa"); }
258test { try toUnicodePass("xn--4db6c", "\xd7\x90\xd7\xaa"); }
259test { try toUnicodePass("\xd7\x90\xd7\xb3\xd7\xaa", "\xd7\x90\xd7\xb3\xd7\xaa"); }
260test { try toUnicodePass("xn--4db6c0a", "\xd7\x90\xd7\xb3\xd7\xaa"); }
261test { try toUnicodePass("\xd7\x907\xd7\xaa", "\xd7\x907\xd7\xaa"); }
262test { try toUnicodePass("xn--7-zhc3f", "\xd7\x907\xd7\xaa"); }
263test { try toUnicodePass("\xd7\x90\xd9\xa7\xd7\xaa", "\xd7\x90\xd9\xa7\xd7\xaa"); }
264test { try toUnicodePass("xn--4db6c6t", "\xd7\x90\xd9\xa7\xd7\xaa"); }
265test { try toUnicodePass("\xe0\xae\xb9\xe0\xaf\x8d\xe2\x80\x8d", "\xe0\xae\xb9\xe0\xaf\x8d\xe2\x80\x8d"); }
266test { try toUnicodePass("xn--dmc4b", "\xe0\xae\xb9\xe0\xaf\x8d"); }
267test { try toUnicodePass("\xe0\xae\xb9\xe0\xaf\x8d", "\xe0\xae\xb9\xe0\xaf\x8d"); }
268test { try toUnicodePass("xn--dmc4b194h", "\xe0\xae\xb9\xe0\xaf\x8d\xe2\x80\x8d"); }
269test { try toUnicodePass("xn--dmc", "\xe0\xae\xb9"); }
270test { try toUnicodePass("\xe0\xae\xb9", "\xe0\xae\xb9"); }
271test { try toUnicodePass("\xe0\xae\xb9\xe0\xaf\x8d\xe2\x80\x8c", "\xe0\xae\xb9\xe0\xaf\x8d\xe2\x80\x8c"); }
272test { try toUnicodePass("xn--dmc4by94h", "\xe0\xae\xb9\xe0\xaf\x8d\xe2\x80\x8c"); }
273test { try toUnicodePass("\xd9\x84\xd9\xb0\xe2\x80\x8c\xdb\xad\xdb\xaf", "\xd9\x84\xd9\xb0\xe2\x80\x8c\xdb\xad\xdb\xaf"); }
274test { try toUnicodePass("xn--ghb2gxqia", "\xd9\x84\xd9\xb0\xdb\xad\xdb\xaf"); }
275test { try toUnicodePass("\xd9\x84\xd9\xb0\xdb\xad\xdb\xaf", "\xd9\x84\xd9\xb0\xdb\xad\xdb\xaf"); }
276test { try toUnicodePass("xn--ghb2gxqia7523a", "\xd9\x84\xd9\xb0\xe2\x80\x8c\xdb\xad\xdb\xaf"); }
277test { try toUnicodePass("\xd9\x84\xd9\xb0\xe2\x80\x8c\xdb\xaf", "\xd9\x84\xd9\xb0\xe2\x80\x8c\xdb\xaf"); }
278test { try toUnicodePass("xn--ghb2g3q", "\xd9\x84\xd9\xb0\xdb\xaf"); }
279test { try toUnicodePass("\xd9\x84\xd9\xb0\xdb\xaf", "\xd9\x84\xd9\xb0\xdb\xaf"); }
280test { try toUnicodePass("xn--ghb2g3qq34f", "\xd9\x84\xd9\xb0\xe2\x80\x8c\xdb\xaf"); }
281test { try toUnicodePass("\xd9\x84\xe2\x80\x8c\xdb\xad\xdb\xaf", "\xd9\x84\xe2\x80\x8c\xdb\xad\xdb\xaf"); }
282test { try toUnicodePass("xn--ghb25aga", "\xd9\x84\xdb\xad\xdb\xaf"); }
283test { try toUnicodePass("\xd9\x84\xdb\xad\xdb\xaf", "\xd9\x84\xdb\xad\xdb\xaf"); }
284test { try toUnicodePass("xn--ghb25aga828w", "\xd9\x84\xe2\x80\x8c\xdb\xad\xdb\xaf"); }
285test { try toUnicodePass("\xd9\x84\xe2\x80\x8c\xdb\xaf", "\xd9\x84\xe2\x80\x8c\xdb\xaf"); }
286test { try toUnicodePass("xn--ghb65a", "\xd9\x84\xdb\xaf"); }
287test { try toUnicodePass("\xd9\x84\xdb\xaf", "\xd9\x84\xdb\xaf"); }
288test { try toUnicodePass("xn--ghb65a953d", "\xd9\x84\xe2\x80\x8c\xdb\xaf"); }
289test { try toUnicodePass("xn--ghb2gxq", "\xd9\x84\xd9\xb0\xdb\xad"); }
290test { try toUnicodePass("\xd9\x84\xd9\xb0\xdb\xad", "\xd9\x84\xd9\xb0\xdb\xad"); }
291test { try toUnicodePass("xn--cmba", "\xdb\xaf\xdb\xaf"); }
292test { try toUnicodePass("\xdb\xaf\xdb\xaf", "\xdb\xaf\xdb\xaf"); }
293test { try toUnicodePass("xn--ghb", "\xd9\x84"); }
294test { try toUnicodePass("\xd9\x84", "\xd9\x84"); }
295test { try toUnicodePass("ascii", "ascii"); }
296test { try toUnicodePass("unicode.org", "unicode.org"); }
297test { try toUnicodePass("\xef\xa5\x91\xf0\xaf\xa1\xa8\xf0\xaf\xa1\xb4\xf0\xaf\xa4\x9f\xf0\xaf\xa5\x9f\xf0\xaf\xa6\xbf", "\xe9\x99\x8b\xe3\x9b\xbc\xe5\xbd\x93\xf0\xa4\x8e\xab\xe7\xab\xae\xe4\x97\x97"); }
298test { try toUnicodePass("\xe9\x99\x8b\xe3\x9b\xbc\xe5\xbd\x93\xf0\xa4\x8e\xab\xe7\xab\xae\xe4\x97\x97", "\xe9\x99\x8b\xe3\x9b\xbc\xe5\xbd\x93\xf0\xa4\x8e\xab\xe7\xab\xae\xe4\x97\x97"); }
299test { try toUnicodePass("xn--snl253bgitxhzwu2arn60c", "\xe9\x99\x8b\xe3\x9b\xbc\xe5\xbd\x93\xf0\xa4\x8e\xab\xe7\xab\xae\xe4\x97\x97"); }
300test { try toUnicodePass("\xe9\x9b\xbb\xf0\xa1\x8d\xaa\xe5\xbc\xb3\xe4\x8e\xab\xe7\xaa\xae\xe4\xb5\x97", "\xe9\x9b\xbb\xf0\xa1\x8d\xaa\xe5\xbc\xb3\xe4\x8e\xab\xe7\xaa\xae\xe4\xb5\x97"); }
301test { try toUnicodePass("xn--kbo60w31ob3z6t3av9z5b", "\xe9\x9b\xbb\xf0\xa1\x8d\xaa\xe5\xbc\xb3\xe4\x8e\xab\xe7\xaa\xae\xe4\xb5\x97"); }
302test { try toUnicodePass("xn--A-1ga", "a\xc3\xb6"); }
303test { try toUnicodePass("a\xc3\xb6", "a\xc3\xb6"); }
304test { try toUnicodePass("ao\xcc\x88", "a\xc3\xb6"); }
305test { try toUnicodePass("AO\xcc\x88", "a\xc3\xb6"); }
306test { try toUnicodePass("A\xc3\x96", "a\xc3\xb6"); }
307test { try toUnicodePass("A\xc3\xb6", "a\xc3\xb6"); }
308test { try toUnicodePass("Ao\xcc\x88", "a\xc3\xb6"); }
309test { try toUnicodePass("\xef\xbc\x9d\xcc\xb8", "\xe2\x89\xa0"); }
310test { try toUnicodePass("\xe2\x89\xa0", "\xe2\x89\xa0"); }
311test { try toUnicodePass("=\xcc\xb8", "\xe2\x89\xa0"); }
312test { try toUnicodePass("xn--1ch", "\xe2\x89\xa0"); }
313test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890A\xcc\x88123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
314test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\x84123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
315test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890A\xcc\x88123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b.", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b."); }
316test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\x84123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b.", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b."); }
317test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890A\xcc\x88123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901c", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901c"); }
318test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\x84123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901c", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa4123456789012345678901234567890123456789012345.123456789012345678901234567890123456789012345678901234567890123.1234567890123456789012345678901234567890123456789012345678901c"); }
319test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890A\xcc\x881234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a"); }
320test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\x841234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a"); }
321test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890A\xcc\x881234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a.", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a."); }
322test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\x841234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a.", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.12345678901234567890123456789012345678901234567890123456789a."); }
323test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890A\xcc\x881234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
324test { try toUnicodePass("123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\x841234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b", "123456789012345678901234567890123456789012345678901234567890123.1234567890\xc3\xa41234567890123456789012345678901234567890123456.123456789012345678901234567890123456789012345678901234567890123.123456789012345678901234567890123456789012345678901234567890b"); }
325test { try toUnicodePass("\xea\xa1\xa3.\xdf\x8f", "\xea\xa1\xa3.\xdf\x8f"); }
326test { try toUnicodePass("xn--8c9a.xn--qsb", "\xea\xa1\xa3.\xdf\x8f"); }
327test { try toUnicodePass("xn--jbf911clb.xn----p9j493ivi4l", "\xe2\x89\xa0\xe1\xa2\x99\xe2\x89\xaf.\xec\x86\xa3-\xe1\xa1\xb4\xe2\xb4\x80"); }
328test { try toUnicodePass("\xe2\x89\xa0\xe1\xa2\x99\xe2\x89\xaf.\xec\x86\xa3-\xe1\xa1\xb4\xe2\xb4\x80", "\xe2\x89\xa0\xe1\xa2\x99\xe2\x89\xaf.\xec\x86\xa3-\xe1\xa1\xb4\xe2\xb4\x80"); }
329test { try toUnicodePass("=\xcc\xb8\xe1\xa2\x99>\xcc\xb8.\xe1\x84\x89\xe1\x85\xa9\xe1\x86\xbe-\xe1\xa1\xb4\xe2\xb4\x80", "\xe2\x89\xa0\xe1\xa2\x99\xe2\x89\xaf.\xec\x86\xa3-\xe1\xa1\xb4\xe2\xb4\x80"); }
330test { try toUnicodePass("=\xcc\xb8\xe1\xa2\x99>\xcc\xb8.\xe1\x84\x89\xe1\x85\xa9\xe1\x86\xbe-\xe1\xa1\xb4\xe1\x82\xa0", "\xe2\x89\xa0\xe1\xa2\x99\xe2\x89\xaf.\xec\x86\xa3-\xe1\xa1\xb4\xe2\xb4\x80"); }
331test { try toUnicodePass("\xe2\x89\xa0\xe1\xa2\x99\xe2\x89\xaf.\xec\x86\xa3-\xe1\xa1\xb4\xe1\x82\xa0", "\xe2\x89\xa0\xe1\xa2\x99\xe2\x89\xaf.\xec\x86\xa3-\xe1\xa1\xb4\xe2\xb4\x80"); }
332test { try toUnicodePass("\xe7\xb9\xb1\xf0\x91\x96\xbf\xe2\x80\x8d.8\xe3\x80\x82", "\xe7\xb9\xb1\xf0\x91\x96\xbf\xe2\x80\x8d.8."); }
333test { try toUnicodePass("xn--gl0as212a.i.", "\xe7\xb9\xb1\xf0\x91\x96\xbf.i."); }
334test { try toUnicodePass("\xe7\xb9\xb1\xf0\x91\x96\xbf.i.", "\xe7\xb9\xb1\xf0\x91\x96\xbf.i."); }
335test { try toUnicodePass("\xe7\xb9\xb1\xf0\x91\x96\xbf.I.", "\xe7\xb9\xb1\xf0\x91\x96\xbf.i."); }
336test { try toUnicodePass("xn--1ug6928ac48e.i.", "\xe7\xb9\xb1\xf0\x91\x96\xbf\xe2\x80\x8d.i."); }
337test { try toUnicodePass("\xe7\xb9\xb1\xf0\x91\x96\xbf\xe2\x80\x8d.i.", "\xe7\xb9\xb1\xf0\x91\x96\xbf\xe2\x80\x8d.i."); }
338test { try toUnicodePass("\xe7\xb9\xb1\xf0\x91\x96\xbf\xe2\x80\x8d.I.", "\xe7\xb9\xb1\xf0\x91\x96\xbf\xe2\x80\x8d.i."); }
339test { try toUnicodePass("xn--ss-59d.", "ss\xdb\xab."); }
340test { try toUnicodePass("ss\xdb\xab.", "ss\xdb\xab."); }
341test { try toUnicodePass("SS\xdb\xab.", "ss\xdb\xab."); }
342test { try toUnicodePass("Ss\xdb\xab.", "ss\xdb\xab."); }
343test { try toUnicodePass("\xf0\x9e\xa4\xb7.\xf0\x90\xae\x90\xf0\x9e\xa2\x81\xf0\x90\xb9\xa0\xd8\xa4", "\xf0\x9e\xa4\xb7.\xf0\x90\xae\x90\xf0\x9e\xa2\x81\xf0\x90\xb9\xa0\xd8\xa4"); }
344test { try toUnicodePass("\xf0\x9e\xa4\xb7.\xf0\x90\xae\x90\xf0\x9e\xa2\x81\xf0\x90\xb9\xa0\xd9\x88\xd9\x94", "\xf0\x9e\xa4\xb7.\xf0\x90\xae\x90\xf0\x9e\xa2\x81\xf0\x90\xb9\xa0\xd8\xa4"); }
345test { try toUnicodePass("\xf0\x9e\xa4\x95.\xf0\x90\xae\x90\xf0\x9e\xa2\x81\xf0\x90\xb9\xa0\xd9\x88\xd9\x94", "\xf0\x9e\xa4\xb7.\xf0\x90\xae\x90\xf0\x9e\xa2\x81\xf0\x90\xb9\xa0\xd8\xa4"); }
346test { try toUnicodePass("\xf0\x9e\xa4\x95.\xf0\x90\xae\x90\xf0\x9e\xa2\x81\xf0\x90\xb9\xa0\xd8\xa4", "\xf0\x9e\xa4\xb7.\xf0\x90\xae\x90\xf0\x9e\xa2\x81\xf0\x90\xb9\xa0\xd8\xa4"); }
347test { try toUnicodePass("xn--ve6h.xn--jgb1694kz0b2176a", "\xf0\x9e\xa4\xb7.\xf0\x90\xae\x90\xf0\x9e\xa2\x81\xf0\x90\xb9\xa0\xd8\xa4"); }
348test { try toUnicodePass("\xf0\x9e\xa4\xa5\xf3\xa0\x85\xae\xef\xbc\x8e\xe1\xa1\x84\xe1\x82\xae", "\xf0\x9e\xa4\xa5.\xe1\xa1\x84\xe2\xb4\x8e"); }
349test { try toUnicodePass("\xf0\x9e\xa4\xa5\xf3\xa0\x85\xae.\xe1\xa1\x84\xe1\x82\xae", "\xf0\x9e\xa4\xa5.\xe1\xa1\x84\xe2\xb4\x8e"); }
350test { try toUnicodePass("\xf0\x9e\xa4\xa5\xf3\xa0\x85\xae.\xe1\xa1\x84\xe2\xb4\x8e", "\xf0\x9e\xa4\xa5.\xe1\xa1\x84\xe2\xb4\x8e"); }
351test { try toUnicodePass("\xf0\x9e\xa4\x83\xf3\xa0\x85\xae.\xe1\xa1\x84\xe1\x82\xae", "\xf0\x9e\xa4\xa5.\xe1\xa1\x84\xe2\xb4\x8e"); }
352test { try toUnicodePass("\xf0\x9e\xa4\x83\xf3\xa0\x85\xae.\xe1\xa1\x84\xe2\xb4\x8e", "\xf0\x9e\xa4\xa5.\xe1\xa1\x84\xe2\xb4\x8e"); }
353test { try toUnicodePass("xn--de6h.xn--37e857h", "\xf0\x9e\xa4\xa5.\xe1\xa1\x84\xe2\xb4\x8e"); }
354test { try toUnicodePass("\xf0\x9e\xa4\xa5.\xe1\xa1\x84\xe2\xb4\x8e", "\xf0\x9e\xa4\xa5.\xe1\xa1\x84\xe2\xb4\x8e"); }
355test { try toUnicodePass("\xf0\x9e\xa4\x83.\xe1\xa1\x84\xe1\x82\xae", "\xf0\x9e\xa4\xa5.\xe1\xa1\x84\xe2\xb4\x8e"); }
356test { try toUnicodePass("\xf0\x9e\xa4\x83.\xe1\xa1\x84\xe2\xb4\x8e", "\xf0\x9e\xa4\xa5.\xe1\xa1\x84\xe2\xb4\x8e"); }
357test { try toUnicodePass("\xf0\x9e\xa4\xa5\xf3\xa0\x85\xae\xef\xbc\x8e\xe1\xa1\x84\xe2\xb4\x8e", "\xf0\x9e\xa4\xa5.\xe1\xa1\x84\xe2\xb4\x8e"); }
358test { try toUnicodePass("\xf0\x9e\xa4\x83\xf3\xa0\x85\xae\xef\xbc\x8e\xe1\xa1\x84\xe1\x82\xae", "\xf0\x9e\xa4\xa5.\xe1\xa1\x84\xe2\xb4\x8e"); }
359test { try toUnicodePass("\xf0\x9e\xa4\x83\xf3\xa0\x85\xae\xef\xbc\x8e\xe1\xa1\x84\xe2\xb4\x8e", "\xf0\x9e\xa4\xa5.\xe1\xa1\x84\xe2\xb4\x8e"); }
360test { try toUnicodePass("\xf0\x9e\xa4\xa5.\xe1\xa1\x84\xe1\x82\xae", "\xf0\x9e\xa4\xa5.\xe1\xa1\x84\xe2\xb4\x8e"); }
361test { try toUnicodePass("xn--9ob.xn--4xa", "\xdd\x96.\xcf\x83"); }
362test { try toUnicodePass("\xdd\x96.\xcf\x83", "\xdd\x96.\xcf\x83"); }
363test { try toUnicodePass("\xdd\x96.\xce\xa3", "\xdd\x96.\xcf\x83"); }
364test { try toUnicodePass("\xc3\x9f\xef\xbd\xa1\xf0\x90\x8b\xb3\xe1\x82\xac\xe0\xbe\xb8", "\xc3\x9f.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
365test { try toUnicodePass("\xc3\x9f\xe3\x80\x82\xf0\x90\x8b\xb3\xe1\x82\xac\xe0\xbe\xb8", "\xc3\x9f.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
366test { try toUnicodePass("\xc3\x9f\xe3\x80\x82\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8", "\xc3\x9f.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
367test { try toUnicodePass("SS\xe3\x80\x82\xf0\x90\x8b\xb3\xe1\x82\xac\xe0\xbe\xb8", "ss.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
368test { try toUnicodePass("ss\xe3\x80\x82\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8", "ss.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
369test { try toUnicodePass("Ss\xe3\x80\x82\xf0\x90\x8b\xb3\xe1\x82\xac\xe0\xbe\xb8", "ss.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
370test { try toUnicodePass("ss.xn--lgd921mvv0m", "ss.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
371test { try toUnicodePass("ss.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8", "ss.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
372test { try toUnicodePass("SS.\xf0\x90\x8b\xb3\xe1\x82\xac\xe0\xbe\xb8", "ss.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
373test { try toUnicodePass("Ss.\xf0\x90\x8b\xb3\xe1\x82\xac\xe0\xbe\xb8", "ss.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
374test { try toUnicodePass("xn--zca.xn--lgd921mvv0m", "\xc3\x9f.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
375test { try toUnicodePass("\xc3\x9f.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8", "\xc3\x9f.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
376test { try toUnicodePass("\xc3\x9f\xef\xbd\xa1\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8", "\xc3\x9f.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
377test { try toUnicodePass("SS\xef\xbd\xa1\xf0\x90\x8b\xb3\xe1\x82\xac\xe0\xbe\xb8", "ss.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
378test { try toUnicodePass("ss\xef\xbd\xa1\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8", "ss.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
379test { try toUnicodePass("Ss\xef\xbd\xa1\xf0\x90\x8b\xb3\xe1\x82\xac\xe0\xbe\xb8", "ss.\xf0\x90\x8b\xb3\xe2\xb4\x8c\xe0\xbe\xb8"); }
380test { try toUnicodePass("\xe1\x9a\xad\xef\xbd\xa1\xf0\x9d\x8c\xa0\xc3\x9f\xf0\x96\xab\xb1", "\xe1\x9a\xad.\xf0\x9d\x8c\xa0\xc3\x9f\xf0\x96\xab\xb1"); }
381test { try toUnicodePass("\xe1\x9a\xad\xe3\x80\x82\xf0\x9d\x8c\xa0\xc3\x9f\xf0\x96\xab\xb1", "\xe1\x9a\xad.\xf0\x9d\x8c\xa0\xc3\x9f\xf0\x96\xab\xb1"); }
382test { try toUnicodePass("\xe1\x9a\xad\xe3\x80\x82\xf0\x9d\x8c\xa0SS\xf0\x96\xab\xb1", "\xe1\x9a\xad.\xf0\x9d\x8c\xa0ss\xf0\x96\xab\xb1"); }
383test { try toUnicodePass("\xe1\x9a\xad\xe3\x80\x82\xf0\x9d\x8c\xa0ss\xf0\x96\xab\xb1", "\xe1\x9a\xad.\xf0\x9d\x8c\xa0ss\xf0\x96\xab\xb1"); }
384test { try toUnicodePass("\xe1\x9a\xad\xe3\x80\x82\xf0\x9d\x8c\xa0Ss\xf0\x96\xab\xb1", "\xe1\x9a\xad.\xf0\x9d\x8c\xa0ss\xf0\x96\xab\xb1"); }
385test { try toUnicodePass("xn--hwe.xn--ss-ci1ub261a", "\xe1\x9a\xad.\xf0\x9d\x8c\xa0ss\xf0\x96\xab\xb1"); }
386test { try toUnicodePass("\xe1\x9a\xad.\xf0\x9d\x8c\xa0ss\xf0\x96\xab\xb1", "\xe1\x9a\xad.\xf0\x9d\x8c\xa0ss\xf0\x96\xab\xb1"); }
387test { try toUnicodePass("\xe1\x9a\xad.\xf0\x9d\x8c\xa0SS\xf0\x96\xab\xb1", "\xe1\x9a\xad.\xf0\x9d\x8c\xa0ss\xf0\x96\xab\xb1"); }
388test { try toUnicodePass("\xe1\x9a\xad.\xf0\x9d\x8c\xa0Ss\xf0\x96\xab\xb1", "\xe1\x9a\xad.\xf0\x9d\x8c\xa0ss\xf0\x96\xab\xb1"); }
389test { try toUnicodePass("xn--hwe.xn--zca4946pblnc", "\xe1\x9a\xad.\xf0\x9d\x8c\xa0\xc3\x9f\xf0\x96\xab\xb1"); }
390test { try toUnicodePass("\xe1\x9a\xad.\xf0\x9d\x8c\xa0\xc3\x9f\xf0\x96\xab\xb1", "\xe1\x9a\xad.\xf0\x9d\x8c\xa0\xc3\x9f\xf0\x96\xab\xb1"); }
391test { try toUnicodePass("\xe1\x9a\xad\xef\xbd\xa1\xf0\x9d\x8c\xa0SS\xf0\x96\xab\xb1", "\xe1\x9a\xad.\xf0\x9d\x8c\xa0ss\xf0\x96\xab\xb1"); }
392test { try toUnicodePass("\xe1\x9a\xad\xef\xbd\xa1\xf0\x9d\x8c\xa0ss\xf0\x96\xab\xb1", "\xe1\x9a\xad.\xf0\x9d\x8c\xa0ss\xf0\x96\xab\xb1"); }
393test { try toUnicodePass("\xe1\x9a\xad\xef\xbd\xa1\xf0\x9d\x8c\xa0Ss\xf0\x96\xab\xb1", "\xe1\x9a\xad.\xf0\x9d\x8c\xa0ss\xf0\x96\xab\xb1"); }
394test { try toUnicodePass("\xf0\x9e\xa5\x93\xef\xbc\x8e\xdc\x98", "\xf0\x9e\xa5\x93.\xdc\x98"); }
395test { try toUnicodePass("\xf0\x9e\xa5\x93.\xdc\x98", "\xf0\x9e\xa5\x93.\xdc\x98"); }
396test { try toUnicodePass("xn--of6h.xn--inb", "\xf0\x9e\xa5\x93.\xdc\x98"); }
397test { try toUnicodePass("\xe1\x82\xba\xf0\x90\x8b\xb8\xf3\xa0\x84\x84\xe3\x80\x82\xf0\x9d\x9f\x9d\xed\x9f\xb6\xe1\x80\xba", "\xe2\xb4\x9a\xf0\x90\x8b\xb8.5\xed\x9f\xb6\xe1\x80\xba"); }
398test { try toUnicodePass("\xe1\x82\xba\xf0\x90\x8b\xb8\xf3\xa0\x84\x84\xe3\x80\x825\xed\x9f\xb6\xe1\x80\xba", "\xe2\xb4\x9a\xf0\x90\x8b\xb8.5\xed\x9f\xb6\xe1\x80\xba"); }
399test { try toUnicodePass("\xe2\xb4\x9a\xf0\x90\x8b\xb8\xf3\xa0\x84\x84\xe3\x80\x825\xed\x9f\xb6\xe1\x80\xba", "\xe2\xb4\x9a\xf0\x90\x8b\xb8.5\xed\x9f\xb6\xe1\x80\xba"); }
400test { try toUnicodePass("xn--ilj2659d.xn--5-dug9054m", "\xe2\xb4\x9a\xf0\x90\x8b\xb8.5\xed\x9f\xb6\xe1\x80\xba"); }
401test { try toUnicodePass("\xe2\xb4\x9a\xf0\x90\x8b\xb8.5\xed\x9f\xb6\xe1\x80\xba", "\xe2\xb4\x9a\xf0\x90\x8b\xb8.5\xed\x9f\xb6\xe1\x80\xba"); }
402test { try toUnicodePass("\xe1\x82\xba\xf0\x90\x8b\xb8.5\xed\x9f\xb6\xe1\x80\xba", "\xe2\xb4\x9a\xf0\x90\x8b\xb8.5\xed\x9f\xb6\xe1\x80\xba"); }
403test { try toUnicodePass("\xe2\xb4\x9a\xf0\x90\x8b\xb8\xf3\xa0\x84\x84\xe3\x80\x82\xf0\x9d\x9f\x9d\xed\x9f\xb6\xe1\x80\xba", "\xe2\xb4\x9a\xf0\x90\x8b\xb8.5\xed\x9f\xb6\xe1\x80\xba"); }
404test { try toUnicodePass("\xe2\x89\xa0.\xe1\xa0\xbf", "\xe2\x89\xa0.\xe1\xa0\xbf"); }
405test { try toUnicodePass("=\xcc\xb8.\xe1\xa0\xbf", "\xe2\x89\xa0.\xe1\xa0\xbf"); }
406test { try toUnicodePass("xn--1ch.xn--y7e", "\xe2\x89\xa0.\xe1\xa0\xbf"); }
407test { try toUnicodePass("\xdc\xa3\xd6\xa3\xef\xbd\xa1\xe3\x8c\xaa", "\xdc\xa3\xd6\xa3.\xe3\x83\x8f\xe3\x82\xa4\xe3\x83\x84"); }
408test { try toUnicodePass("\xdc\xa3\xd6\xa3\xe3\x80\x82\xe3\x83\x8f\xe3\x82\xa4\xe3\x83\x84", "\xdc\xa3\xd6\xa3.\xe3\x83\x8f\xe3\x82\xa4\xe3\x83\x84"); }
409test { try toUnicodePass("xn--ucb18e.xn--eck4c5a", "\xdc\xa3\xd6\xa3.\xe3\x83\x8f\xe3\x82\xa4\xe3\x83\x84"); }
410test { try toUnicodePass("\xdc\xa3\xd6\xa3.\xe3\x83\x8f\xe3\x82\xa4\xe3\x83\x84", "\xdc\xa3\xd6\xa3.\xe3\x83\x8f\xe3\x82\xa4\xe3\x83\x84"); }
411test { try toUnicodePass("xn--skb", "\xda\xb9"); }
412test { try toUnicodePass("\xda\xb9", "\xda\xb9"); }
413test { try toUnicodePass("\xc3\x9f\xe0\xa7\x81\xe1\xb7\xad\xe3\x80\x82\xd8\xa08\xe2\x82\x85", "\xc3\x9f\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085"); }
414test { try toUnicodePass("\xc3\x9f\xe0\xa7\x81\xe1\xb7\xad\xe3\x80\x82\xd8\xa085", "\xc3\x9f\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085"); }
415test { try toUnicodePass("SS\xe0\xa7\x81\xe1\xb7\xad\xe3\x80\x82\xd8\xa085", "ss\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085"); }
416test { try toUnicodePass("ss\xe0\xa7\x81\xe1\xb7\xad\xe3\x80\x82\xd8\xa085", "ss\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085"); }
417test { try toUnicodePass("Ss\xe0\xa7\x81\xe1\xb7\xad\xe3\x80\x82\xd8\xa085", "ss\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085"); }
418test { try toUnicodePass("xn--ss-e2f077r.xn--85-psd", "ss\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085"); }
419test { try toUnicodePass("ss\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085", "ss\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085"); }
420test { try toUnicodePass("SS\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085", "ss\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085"); }
421test { try toUnicodePass("Ss\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085", "ss\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085"); }
422test { try toUnicodePass("xn--zca266bwrr.xn--85-psd", "\xc3\x9f\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085"); }
423test { try toUnicodePass("\xc3\x9f\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085", "\xc3\x9f\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085"); }
424test { try toUnicodePass("SS\xe0\xa7\x81\xe1\xb7\xad\xe3\x80\x82\xd8\xa08\xe2\x82\x85", "ss\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085"); }
425test { try toUnicodePass("ss\xe0\xa7\x81\xe1\xb7\xad\xe3\x80\x82\xd8\xa08\xe2\x82\x85", "ss\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085"); }
426test { try toUnicodePass("Ss\xe0\xa7\x81\xe1\xb7\xad\xe3\x80\x82\xd8\xa08\xe2\x82\x85", "ss\xe0\xa7\x81\xe1\xb7\xad.\xd8\xa085"); }
427test { try toUnicodePass("\xef\xb8\x8d\xe0\xaa\x9b\xe3\x80\x82\xe5\xb5\xa8", "\xe0\xaa\x9b.\xe5\xb5\xa8"); }
428test { try toUnicodePass("xn--6dc.xn--tot", "\xe0\xaa\x9b.\xe5\xb5\xa8"); }
429test { try toUnicodePass("\xe0\xaa\x9b.\xe5\xb5\xa8", "\xe0\xaa\x9b.\xe5\xb5\xa8"); }
430test { try toUnicodePass("xn--t6f5138v", "\xf0\xa6\x80\xbe\xe1\xb3\xa0"); }
431test { try toUnicodePass("\xf0\xa6\x80\xbe\xe1\xb3\xa0", "\xf0\xa6\x80\xbe\xe1\xb3\xa0"); }
432test { try toUnicodePass("xn--p8e.xn--1ch3a7084l", "\xe1\xa1\x99.\xe2\x89\xaf\xf0\x90\x8b\xb2\xe2\x89\xa0"); }
433test { try toUnicodePass("\xe1\xa1\x99.\xe2\x89\xaf\xf0\x90\x8b\xb2\xe2\x89\xa0", "\xe1\xa1\x99.\xe2\x89\xaf\xf0\x90\x8b\xb2\xe2\x89\xa0"); }
434test { try toUnicodePass("\xe1\xa1\x99.>\xcc\xb8\xf0\x90\x8b\xb2=\xcc\xb8", "\xe1\xa1\x99.\xe2\x89\xaf\xf0\x90\x8b\xb2\xe2\x89\xa0"); }
435test { try toUnicodePass("xn--u4e969b.xn--1ch", "\xe2\x85\x8e\xe1\x9f\x92.\xe2\x89\xa0"); }
436test { try toUnicodePass("\xe2\x85\x8e\xe1\x9f\x92.\xe2\x89\xa0", "\xe2\x85\x8e\xe1\x9f\x92.\xe2\x89\xa0"); }
437test { try toUnicodePass("\xe2\x85\x8e\xe1\x9f\x92.=\xcc\xb8", "\xe2\x85\x8e\xe1\x9f\x92.\xe2\x89\xa0"); }
438test { try toUnicodePass("\xe2\x84\xb2\xe1\x9f\x92.=\xcc\xb8", "\xe2\x85\x8e\xe1\x9f\x92.\xe2\x89\xa0"); }
439test { try toUnicodePass("\xe2\x84\xb2\xe1\x9f\x92.\xe2\x89\xa0", "\xe2\x85\x8e\xe1\x9f\x92.\xe2\x89\xa0"); }
440test { try toUnicodePass("xn--9-mfs8024b.", "9\xe9\x9a\x81\xe2\xaf\xae."); }
441test { try toUnicodePass("9\xe9\x9a\x81\xe2\xaf\xae.", "9\xe9\x9a\x81\xe2\xaf\xae."); }
442test { try toUnicodePass("xn--2ib43l.xn--te6h", "\xd9\xbd\xe0\xa5\x83.\xf0\x9e\xa4\xb5"); }
443test { try toUnicodePass("\xd9\xbd\xe0\xa5\x83.\xf0\x9e\xa4\xb5", "\xd9\xbd\xe0\xa5\x83.\xf0\x9e\xa4\xb5"); }
444test { try toUnicodePass("\xd9\xbd\xe0\xa5\x83.\xf0\x9e\xa4\x93", "\xd9\xbd\xe0\xa5\x83.\xf0\x9e\xa4\xb5"); }
445test { try toUnicodePass("\xea\xa7\x90\xd3\x80\xe1\xae\xaa\xe0\xa3\xb6\xef\xbc\x8e\xeb\x88\xb5", "\xea\xa7\x90\xd3\x8f\xe1\xae\xaa\xe0\xa3\xb6.\xeb\x88\xb5"); }
446test { try toUnicodePass("\xea\xa7\x90\xd3\x80\xe1\xae\xaa\xe0\xa3\xb6\xef\xbc\x8e\xe1\x84\x82\xe1\x85\xaf\xe1\x86\xbc", "\xea\xa7\x90\xd3\x8f\xe1\xae\xaa\xe0\xa3\xb6.\xeb\x88\xb5"); }
447test { try toUnicodePass("\xea\xa7\x90\xd3\x80\xe1\xae\xaa\xe0\xa3\xb6.\xeb\x88\xb5", "\xea\xa7\x90\xd3\x8f\xe1\xae\xaa\xe0\xa3\xb6.\xeb\x88\xb5"); }
448test { try toUnicodePass("\xea\xa7\x90\xd3\x80\xe1\xae\xaa\xe0\xa3\xb6.\xe1\x84\x82\xe1\x85\xaf\xe1\x86\xbc", "\xea\xa7\x90\xd3\x8f\xe1\xae\xaa\xe0\xa3\xb6.\xeb\x88\xb5"); }
449test { try toUnicodePass("\xea\xa7\x90\xd3\x8f\xe1\xae\xaa\xe0\xa3\xb6.\xe1\x84\x82\xe1\x85\xaf\xe1\x86\xbc", "\xea\xa7\x90\xd3\x8f\xe1\xae\xaa\xe0\xa3\xb6.\xeb\x88\xb5"); }
450test { try toUnicodePass("\xea\xa7\x90\xd3\x8f\xe1\xae\xaa\xe0\xa3\xb6.\xeb\x88\xb5", "\xea\xa7\x90\xd3\x8f\xe1\xae\xaa\xe0\xa3\xb6.\xeb\x88\xb5"); }
451test { try toUnicodePass("xn--s5a04sn4u297k.xn--2e1b", "\xea\xa7\x90\xd3\x8f\xe1\xae\xaa\xe0\xa3\xb6.\xeb\x88\xb5"); }
452test { try toUnicodePass("\xea\xa7\x90\xd3\x8f\xe1\xae\xaa\xe0\xa3\xb6\xef\xbc\x8e\xe1\x84\x82\xe1\x85\xaf\xe1\x86\xbc", "\xea\xa7\x90\xd3\x8f\xe1\xae\xaa\xe0\xa3\xb6.\xeb\x88\xb5"); }
453test { try toUnicodePass("\xea\xa7\x90\xd3\x8f\xe1\xae\xaa\xe0\xa3\xb6\xef\xbc\x8e\xeb\x88\xb5", "\xea\xa7\x90\xd3\x8f\xe1\xae\xaa\xe0\xa3\xb6.\xeb\x88\xb5"); }
454test { try toUnicodePass("xn--9hb7344k.", "\xf0\x90\xab\x87\xd9\xa1."); }
455test { try toUnicodePass("\xf0\x90\xab\x87\xd9\xa1.", "\xf0\x90\xab\x87\xd9\xa1."); }
456test { try toUnicodePass("\xdf\xa5.\xda\xb5", "\xdf\xa5.\xda\xb5"); }
457test { try toUnicodePass("xn--dtb.xn--okb", "\xdf\xa5.\xda\xb5"); }
458test { try toUnicodePass("xn--3e6h", "\xf0\x9e\xa4\xbf"); }
459test { try toUnicodePass("\xf0\x9e\xa4\xbf", "\xf0\x9e\xa4\xbf"); }
460test { try toUnicodePass("\xf0\x9e\xa4\x9d", "\xf0\x9e\xa4\xbf"); }
461test { try toUnicodePass("\xda\xb9\xef\xbc\x8e\xe1\xa1\xb3\xe1\x85\x9f", "\xda\xb9.\xe1\xa1\xb3"); }
462test { try toUnicodePass("\xda\xb9.\xe1\xa1\xb3\xe1\x85\x9f", "\xda\xb9.\xe1\xa1\xb3"); }
463test { try toUnicodePass("xn--skb.xn--g9e", "\xda\xb9.\xe1\xa1\xb3"); }
464test { try toUnicodePass("\xda\xb9.\xe1\xa1\xb3", "\xda\xb9.\xe1\xa1\xb3"); }
465test { try toUnicodePass("xn--ss-4epx629f.xn--ifh802b6a", "ss\xea\xab\xb6\xe1\xa2\xa5.\xe2\x8a\xb6\xe2\xb4\xa1\xe2\xb4\x96"); }
466test { try toUnicodePass("ss\xea\xab\xb6\xe1\xa2\xa5.\xe2\x8a\xb6\xe2\xb4\xa1\xe2\xb4\x96", "ss\xea\xab\xb6\xe1\xa2\xa5.\xe2\x8a\xb6\xe2\xb4\xa1\xe2\xb4\x96"); }
467test { try toUnicodePass("SS\xea\xab\xb6\xe1\xa2\xa5.\xe2\x8a\xb6\xe1\x83\x81\xe1\x82\xb6", "ss\xea\xab\xb6\xe1\xa2\xa5.\xe2\x8a\xb6\xe2\xb4\xa1\xe2\xb4\x96"); }
468test { try toUnicodePass("Ss\xea\xab\xb6\xe1\xa2\xa5.\xe2\x8a\xb6\xe1\x83\x81\xe2\xb4\x96", "ss\xea\xab\xb6\xe1\xa2\xa5.\xe2\x8a\xb6\xe2\xb4\xa1\xe2\xb4\x96"); }
469test { try toUnicodePass("\xe2\x89\xa0\xe3\x80\x82\xf0\x9f\x9e\xb3\xf0\x9d\x9f\xb2", "\xe2\x89\xa0.\xf0\x9f\x9e\xb36"); }
470test { try toUnicodePass("=\xcc\xb8\xe3\x80\x82\xf0\x9f\x9e\xb3\xf0\x9d\x9f\xb2", "\xe2\x89\xa0.\xf0\x9f\x9e\xb36"); }
471test { try toUnicodePass("\xe2\x89\xa0\xe3\x80\x82\xf0\x9f\x9e\xb36", "\xe2\x89\xa0.\xf0\x9f\x9e\xb36"); }
472test { try toUnicodePass("=\xcc\xb8\xe3\x80\x82\xf0\x9f\x9e\xb36", "\xe2\x89\xa0.\xf0\x9f\x9e\xb36"); }
473test { try toUnicodePass("xn--1ch.xn--6-dl4s", "\xe2\x89\xa0.\xf0\x9f\x9e\xb36"); }
474test { try toUnicodePass("\xe2\x89\xa0.\xf0\x9f\x9e\xb36", "\xe2\x89\xa0.\xf0\x9f\x9e\xb36"); }
475test { try toUnicodePass("=\xcc\xb8.\xf0\x9f\x9e\xb36", "\xe2\x89\xa0.\xf0\x9f\x9e\xb36"); }
476test { try toUnicodePass("j", "j"); }
477test { try toUnicodePass("xn--rt6a.", "\xe9\xb1\x8a."); }
478test { try toUnicodePass("\xe9\xb1\x8a.", "\xe9\xb1\x8a."); }
479test { try toUnicodePass("xn--4-0bd15808a.", "\xf0\x9e\xa4\xba\xdf\x8c4."); }
480test { try toUnicodePass("\xf0\x9e\xa4\xba\xdf\x8c4.", "\xf0\x9e\xa4\xba\xdf\x8c4."); }
481test { try toUnicodePass("\xf0\x9e\xa4\x98\xdf\x8c4.", "\xf0\x9e\xa4\xba\xdf\x8c4."); }
482test { try toUnicodePass("\xe2\xbe\x86\xef\xbc\x8e\xea\xa1\x88\xef\xbc\x95\xe2\x89\xaf\xc3\x9f", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xaf\xc3\x9f"); }
483test { try toUnicodePass("\xe2\xbe\x86\xef\xbc\x8e\xea\xa1\x88\xef\xbc\x95>\xcc\xb8\xc3\x9f", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xaf\xc3\x9f"); }
484test { try toUnicodePass("\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xaf\xc3\x9f", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xaf\xc3\x9f"); }
485test { try toUnicodePass("\xe8\x88\x8c.\xea\xa1\x885>\xcc\xb8\xc3\x9f", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xaf\xc3\x9f"); }
486test { try toUnicodePass("\xe8\x88\x8c.\xea\xa1\x885>\xcc\xb8SS", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafss"); }
487test { try toUnicodePass("\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafSS", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafss"); }
488test { try toUnicodePass("\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafss", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafss"); }
489test { try toUnicodePass("\xe8\x88\x8c.\xea\xa1\x885>\xcc\xb8ss", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafss"); }
490test { try toUnicodePass("\xe8\x88\x8c.\xea\xa1\x885>\xcc\xb8Ss", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafss"); }
491test { try toUnicodePass("\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafSs", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafss"); }
492test { try toUnicodePass("xn--tc1a.xn--5ss-3m2a5009e", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafss"); }
493test { try toUnicodePass("xn--tc1a.xn--5-qfa988w745i", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xaf\xc3\x9f"); }
494test { try toUnicodePass("\xe2\xbe\x86\xef\xbc\x8e\xea\xa1\x88\xef\xbc\x95>\xcc\xb8SS", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafss"); }
495test { try toUnicodePass("\xe2\xbe\x86\xef\xbc\x8e\xea\xa1\x88\xef\xbc\x95\xe2\x89\xafSS", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafss"); }
496test { try toUnicodePass("\xe2\xbe\x86\xef\xbc\x8e\xea\xa1\x88\xef\xbc\x95\xe2\x89\xafss", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafss"); }
497test { try toUnicodePass("\xe2\xbe\x86\xef\xbc\x8e\xea\xa1\x88\xef\xbc\x95>\xcc\xb8ss", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafss"); }
498test { try toUnicodePass("\xe2\xbe\x86\xef\xbc\x8e\xea\xa1\x88\xef\xbc\x95>\xcc\xb8Ss", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafss"); }
499test { try toUnicodePass("\xe2\xbe\x86\xef\xbc\x8e\xea\xa1\x88\xef\xbc\x95\xe2\x89\xafSs", "\xe8\x88\x8c.\xea\xa1\x885\xe2\x89\xafss"); }
500test { try toUnicodePass("\xf0\x9e\xa4\xaa.\xcf\x82", "\xf0\x9e\xa4\xaa.\xcf\x82"); }
501test { try toUnicodePass("\xf0\x9e\xa4\x88.\xce\xa3", "\xf0\x9e\xa4\xaa.\xcf\x83"); }
502test { try toUnicodePass("\xf0\x9e\xa4\xaa.\xcf\x83", "\xf0\x9e\xa4\xaa.\xcf\x83"); }
503test { try toUnicodePass("\xf0\x9e\xa4\x88.\xcf\x83", "\xf0\x9e\xa4\xaa.\xcf\x83"); }
504test { try toUnicodePass("xn--ie6h.xn--4xa", "\xf0\x9e\xa4\xaa.\xcf\x83"); }
505test { try toUnicodePass("\xf0\x9e\xa4\x88.\xcf\x82", "\xf0\x9e\xa4\xaa.\xcf\x82"); }
506test { try toUnicodePass("xn--ie6h.xn--3xa", "\xf0\x9e\xa4\xaa.\xcf\x82"); }
507test { try toUnicodePass("\xf0\x9e\xa4\xaa.\xce\xa3", "\xf0\x9e\xa4\xaa.\xcf\x83"); }
508test { try toUnicodePass("xn--ilj.xn--4xa", "\xe2\xb4\x9a.\xcf\x83"); }
509test { try toUnicodePass("\xe2\xb4\x9a.\xcf\x83", "\xe2\xb4\x9a.\xcf\x83"); }
510test { try toUnicodePass("\xe1\x82\xba.\xce\xa3", "\xe2\xb4\x9a.\xcf\x83"); }
511test { try toUnicodePass("\xe2\xb4\x9a.\xcf\x82", "\xe2\xb4\x9a.\xcf\x82"); }
512test { try toUnicodePass("\xe1\x82\xba.\xcf\x82", "\xe2\xb4\x9a.\xcf\x82"); }
513test { try toUnicodePass("xn--ilj.xn--3xa", "\xe2\xb4\x9a.\xcf\x82"); }
514test { try toUnicodePass("\xe1\x82\xba.\xcf\x83", "\xe2\xb4\x9a.\xcf\x83"); }
515test { try toUnicodePass("\xe6\xb7\xbd\xe3\x80\x82\xe1\xa0\xbe", "\xe6\xb7\xbd.\xe1\xa0\xbe"); }
516test { try toUnicodePass("xn--34w.xn--x7e", "\xe6\xb7\xbd.\xe1\xa0\xbe"); }
517test { try toUnicodePass("\xe6\xb7\xbd.\xe1\xa0\xbe", "\xe6\xb7\xbd.\xe1\xa0\xbe"); }
518test { try toUnicodePass("\xea\xa1\xa0\xef\xbc\x8e\xdb\xb2", "\xea\xa1\xa0.\xdb\xb2"); }
519test { try toUnicodePass("\xea\xa1\xa0.\xdb\xb2", "\xea\xa1\xa0.\xdb\xb2"); }
520test { try toUnicodePass("xn--5c9a.xn--fmb", "\xea\xa1\xa0.\xdb\xb2"); }
521test { try toUnicodePass("1.2h", "1.2h"); }
522test { try toUnicodePass("xn--skjy82u.xn--gdh", "\xe2\xb4\x81\xe7\x95\x9d.\xe2\x89\xae"); }
523test { try toUnicodePass("\xe2\xb4\x81\xe7\x95\x9d.\xe2\x89\xae", "\xe2\xb4\x81\xe7\x95\x9d.\xe2\x89\xae"); }
524test { try toUnicodePass("\xe2\xb4\x81\xe7\x95\x9d.<\xcc\xb8", "\xe2\xb4\x81\xe7\x95\x9d.\xe2\x89\xae"); }
525test { try toUnicodePass("\xe1\x82\xa1\xe7\x95\x9d.<\xcc\xb8", "\xe2\xb4\x81\xe7\x95\x9d.\xe2\x89\xae"); }
526test { try toUnicodePass("\xe1\x82\xa1\xe7\x95\x9d.\xe2\x89\xae", "\xe2\xb4\x81\xe7\x95\x9d.\xe2\x89\xae"); }
527test { try toUnicodePass("\xf0\x9f\x95\xbc\xef\xbc\x8e\xef\xbe\xa0", "\xf0\x9f\x95\xbc."); }
528test { try toUnicodePass("\xf0\x9f\x95\xbc.\xe1\x85\xa0", "\xf0\x9f\x95\xbc."); }
529test { try toUnicodePass("xn--my8h.", "\xf0\x9f\x95\xbc."); }
530test { try toUnicodePass("\xf0\x9f\x95\xbc.", "\xf0\x9f\x95\xbc."); }
531test { try toUnicodePass("\xcf\x82\xe1\x83\x85\xe3\x80\x82\xdd\x9a", "\xcf\x82\xe2\xb4\xa5.\xdd\x9a"); }
532test { try toUnicodePass("\xcf\x82\xe2\xb4\xa5\xe3\x80\x82\xdd\x9a", "\xcf\x82\xe2\xb4\xa5.\xdd\x9a"); }
533test { try toUnicodePass("\xce\xa3\xe1\x83\x85\xe3\x80\x82\xdd\x9a", "\xcf\x83\xe2\xb4\xa5.\xdd\x9a"); }
534test { try toUnicodePass("\xcf\x83\xe2\xb4\xa5\xe3\x80\x82\xdd\x9a", "\xcf\x83\xe2\xb4\xa5.\xdd\x9a"); }
535test { try toUnicodePass("\xce\xa3\xe2\xb4\xa5\xe3\x80\x82\xdd\x9a", "\xcf\x83\xe2\xb4\xa5.\xdd\x9a"); }
536test { try toUnicodePass("xn--4xa203s.xn--epb", "\xcf\x83\xe2\xb4\xa5.\xdd\x9a"); }
537test { try toUnicodePass("\xcf\x83\xe2\xb4\xa5.\xdd\x9a", "\xcf\x83\xe2\xb4\xa5.\xdd\x9a"); }
538test { try toUnicodePass("\xce\xa3\xe1\x83\x85.\xdd\x9a", "\xcf\x83\xe2\xb4\xa5.\xdd\x9a"); }
539test { try toUnicodePass("\xce\xa3\xe2\xb4\xa5.\xdd\x9a", "\xcf\x83\xe2\xb4\xa5.\xdd\x9a"); }
540test { try toUnicodePass("xn--3xa403s.xn--epb", "\xcf\x82\xe2\xb4\xa5.\xdd\x9a"); }
541test { try toUnicodePass("\xcf\x82\xe2\xb4\xa5.\xdd\x9a", "\xcf\x82\xe2\xb4\xa5.\xdd\x9a"); }
542test { try toUnicodePass("xn--vkb.xn--08e172a", "\xda\xbc.\xe1\xba\x8f\xe1\xa1\xa4"); }
543test { try toUnicodePass("\xda\xbc.\xe1\xba\x8f\xe1\xa1\xa4", "\xda\xbc.\xe1\xba\x8f\xe1\xa1\xa4"); }
544test { try toUnicodePass("\xda\xbc.y\xcc\x87\xe1\xa1\xa4", "\xda\xbc.\xe1\xba\x8f\xe1\xa1\xa4"); }
545test { try toUnicodePass("\xda\xbc.Y\xcc\x87\xe1\xa1\xa4", "\xda\xbc.\xe1\xba\x8f\xe1\xa1\xa4"); }
546test { try toUnicodePass("\xda\xbc.\xe1\xba\x8e\xe1\xa1\xa4", "\xda\xbc.\xe1\xba\x8f\xe1\xa1\xa4"); }
547test { try toUnicodePass("xn--pt9c.xn--0kjya", "\xf0\x90\xa9\x97.\xe2\xb4\x89\xe2\xb4\x95"); }
548test { try toUnicodePass("\xf0\x90\xa9\x97.\xe2\xb4\x89\xe2\xb4\x95", "\xf0\x90\xa9\x97.\xe2\xb4\x89\xe2\xb4\x95"); }
549test { try toUnicodePass("\xf0\x90\xa9\x97.\xe1\x82\xa9\xe1\x82\xb5", "\xf0\x90\xa9\x97.\xe2\xb4\x89\xe2\xb4\x95"); }
550test { try toUnicodePass("\xf0\x90\xa9\x97.\xe1\x82\xa9\xe2\xb4\x95", "\xf0\x90\xa9\x97.\xe2\xb4\x89\xe2\xb4\x95"); }
551test { try toUnicodePass("\xf0\xb2\xa4\xb120.\xe9\x9f\xb3.\xea\xa1\xa61.", "\xf0\xb2\xa4\xb120.\xe9\x9f\xb3.\xea\xa1\xa61."); }
552test { try toUnicodePass("xn--20-9802c.xn--0w5a.xn--1-eg4e.", "\xf0\xb2\xa4\xb120.\xe9\x9f\xb3.\xea\xa1\xa61."); }
553test { try toUnicodePass("\xe1\x82\xb5\xe3\x80\x82\xdb\xb0\xe2\x89\xae\xc3\x9f\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xae\xc3\x9f\xdd\x85"); }
554test { try toUnicodePass("\xe1\x82\xb5\xe3\x80\x82\xdb\xb0<\xcc\xb8\xc3\x9f\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xae\xc3\x9f\xdd\x85"); }
555test { try toUnicodePass("\xe2\xb4\x95\xe3\x80\x82\xdb\xb0<\xcc\xb8\xc3\x9f\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xae\xc3\x9f\xdd\x85"); }
556test { try toUnicodePass("\xe2\xb4\x95\xe3\x80\x82\xdb\xb0\xe2\x89\xae\xc3\x9f\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xae\xc3\x9f\xdd\x85"); }
557test { try toUnicodePass("\xe1\x82\xb5\xe3\x80\x82\xdb\xb0\xe2\x89\xaeSS\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xaess\xdd\x85"); }
558test { try toUnicodePass("\xe1\x82\xb5\xe3\x80\x82\xdb\xb0<\xcc\xb8SS\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xaess\xdd\x85"); }
559test { try toUnicodePass("\xe2\xb4\x95\xe3\x80\x82\xdb\xb0<\xcc\xb8ss\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xaess\xdd\x85"); }
560test { try toUnicodePass("\xe2\xb4\x95\xe3\x80\x82\xdb\xb0\xe2\x89\xaess\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xaess\xdd\x85"); }
561test { try toUnicodePass("\xe1\x82\xb5\xe3\x80\x82\xdb\xb0\xe2\x89\xaeSs\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xaess\xdd\x85"); }
562test { try toUnicodePass("\xe1\x82\xb5\xe3\x80\x82\xdb\xb0<\xcc\xb8Ss\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xaess\xdd\x85"); }
563test { try toUnicodePass("xn--dlj.xn--ss-jbe65aw27i", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xaess\xdd\x85"); }
564test { try toUnicodePass("\xe2\xb4\x95.\xdb\xb0\xe2\x89\xaess\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xaess\xdd\x85"); }
565test { try toUnicodePass("\xe2\xb4\x95.\xdb\xb0<\xcc\xb8ss\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xaess\xdd\x85"); }
566test { try toUnicodePass("\xe1\x82\xb5.\xdb\xb0<\xcc\xb8SS\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xaess\xdd\x85"); }
567test { try toUnicodePass("\xe1\x82\xb5.\xdb\xb0\xe2\x89\xaeSS\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xaess\xdd\x85"); }
568test { try toUnicodePass("\xe1\x82\xb5.\xdb\xb0\xe2\x89\xaeSs\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xaess\xdd\x85"); }
569test { try toUnicodePass("\xe1\x82\xb5.\xdb\xb0<\xcc\xb8Ss\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xaess\xdd\x85"); }
570test { try toUnicodePass("xn--dlj.xn--zca912alh227g", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xae\xc3\x9f\xdd\x85"); }
571test { try toUnicodePass("\xe2\xb4\x95.\xdb\xb0\xe2\x89\xae\xc3\x9f\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xae\xc3\x9f\xdd\x85"); }
572test { try toUnicodePass("\xe2\xb4\x95.\xdb\xb0<\xcc\xb8\xc3\x9f\xdd\x85", "\xe2\xb4\x95.\xdb\xb0\xe2\x89\xae\xc3\x9f\xdd\x85"); }
573test { try toUnicodePass("xn--ge6h.xn--oc9a", "\xf0\x9e\xa4\xa8.\xea\xa1\x8f"); }
574test { try toUnicodePass("\xf0\x9e\xa4\xa8.\xea\xa1\x8f", "\xf0\x9e\xa4\xa8.\xea\xa1\x8f"); }
575test { try toUnicodePass("\xf0\x9e\xa4\x86.\xea\xa1\x8f", "\xf0\x9e\xa4\xa8.\xea\xa1\x8f"); }
576test { try toUnicodePass("\xe9\xbd\x99--\xf0\x9d\x9f\xb0.\xc3\x9f", "\xe9\xbd\x99--4.\xc3\x9f"); }
577test { try toUnicodePass("\xe9\xbd\x99--4.\xc3\x9f", "\xe9\xbd\x99--4.\xc3\x9f"); }
578test { try toUnicodePass("\xe9\xbd\x99--4.SS", "\xe9\xbd\x99--4.ss"); }
579test { try toUnicodePass("\xe9\xbd\x99--4.ss", "\xe9\xbd\x99--4.ss"); }
580test { try toUnicodePass("\xe9\xbd\x99--4.Ss", "\xe9\xbd\x99--4.ss"); }
581test { try toUnicodePass("xn----4-p16k.ss", "\xe9\xbd\x99--4.ss"); }
582test { try toUnicodePass("xn----4-p16k.xn--zca", "\xe9\xbd\x99--4.\xc3\x9f"); }
583test { try toUnicodePass("\xe9\xbd\x99--\xf0\x9d\x9f\xb0.SS", "\xe9\xbd\x99--4.ss"); }
584test { try toUnicodePass("\xe9\xbd\x99--\xf0\x9d\x9f\xb0.ss", "\xe9\xbd\x99--4.ss"); }
585test { try toUnicodePass("\xe9\xbd\x99--\xf0\x9d\x9f\xb0.Ss", "\xe9\xbd\x99--4.ss"); }
586test { try toUnicodePass("xn--9-i0j5967eg3qz.ss", "\xf0\xb2\xae\x9a9\xea\x8d\xa9\xe1\x9f\x93.ss"); }
587test { try toUnicodePass("\xf0\xb2\xae\x9a9\xea\x8d\xa9\xe1\x9f\x93.ss", "\xf0\xb2\xae\x9a9\xea\x8d\xa9\xe1\x9f\x93.ss"); }
588test { try toUnicodePass("\xf0\xb2\xae\x9a9\xea\x8d\xa9\xe1\x9f\x93.SS", "\xf0\xb2\xae\x9a9\xea\x8d\xa9\xe1\x9f\x93.ss"); }
589test { try toUnicodePass("\xea\x97\xb7\xf0\x91\x86\x80.\xdd\x9d\xf0\x90\xa9\x92", "\xea\x97\xb7\xf0\x91\x86\x80.\xdd\x9d\xf0\x90\xa9\x92"); }
590test { try toUnicodePass("xn--ju8a625r.xn--hpb0073k", "\xea\x97\xb7\xf0\x91\x86\x80.\xdd\x9d\xf0\x90\xa9\x92"); }
591test { try toUnicodePass("\xcf\x82.\xd9\x81\xd9\x85\xd9\x8a\xf0\x9f\x9e\x9b1.", "\xcf\x82.\xd9\x81\xd9\x85\xd9\x8a\xf0\x9f\x9e\x9b1."); }
592test { try toUnicodePass("\xce\xa3.\xd9\x81\xd9\x85\xd9\x8a\xf0\x9f\x9e\x9b1.", "\xcf\x83.\xd9\x81\xd9\x85\xd9\x8a\xf0\x9f\x9e\x9b1."); }
593test { try toUnicodePass("\xcf\x83.\xd9\x81\xd9\x85\xd9\x8a\xf0\x9f\x9e\x9b1.", "\xcf\x83.\xd9\x81\xd9\x85\xd9\x8a\xf0\x9f\x9e\x9b1."); }
594test { try toUnicodePass("xn--4xa.xn--1-gocmu97674d.", "\xcf\x83.\xd9\x81\xd9\x85\xd9\x8a\xf0\x9f\x9e\x9b1."); }
595test { try toUnicodePass("xn--3xa.xn--1-gocmu97674d.", "\xcf\x82.\xd9\x81\xd9\x85\xd9\x8a\xf0\x9f\x9e\x9b1."); }
596test { try toUnicodePass("xn--hva754s.", "\xe2\xb4\x96\xcd\xa6."); }
597test { try toUnicodePass("\xe2\xb4\x96\xcd\xa6.", "\xe2\xb4\x96\xcd\xa6."); }
598test { try toUnicodePass("\xe1\x82\xb6\xcd\xa6.", "\xe2\xb4\x96\xcd\xa6."); }
599test { try toUnicodePass("xn--hzb.xn--ukj4430l", "\xe0\xa2\xbb.\xe2\xb4\x83\xf0\x9e\x80\x92"); }
600test { try toUnicodePass("\xe0\xa2\xbb.\xe2\xb4\x83\xf0\x9e\x80\x92", "\xe0\xa2\xbb.\xe2\xb4\x83\xf0\x9e\x80\x92"); }
601test { try toUnicodePass("\xe0\xa2\xbb.\xe1\x82\xa3\xf0\x9e\x80\x92", "\xe0\xa2\xbb.\xe2\xb4\x83\xf0\x9e\x80\x92"); }
602test { try toUnicodePass("xn--p9ut19m.xn----mck373i", "\xe6\x94\x8c\xea\xaf\xad.\xe1\xa2\x96-\xe2\xb4\x98"); }
603test { try toUnicodePass("\xe6\x94\x8c\xea\xaf\xad.\xe1\xa2\x96-\xe2\xb4\x98", "\xe6\x94\x8c\xea\xaf\xad.\xe1\xa2\x96-\xe2\xb4\x98"); }
604test { try toUnicodePass("\xe6\x94\x8c\xea\xaf\xad.\xe1\xa2\x96-\xe1\x82\xb8", "\xe6\x94\x8c\xea\xaf\xad.\xe1\xa2\x96-\xe2\xb4\x98"); }
605test { try toUnicodePass("xn--9r8a.16.xn--3-nyc0117m", "\xea\x96\xa8.16.3\xed\x88\x92\xdb\xb3"); }
606test { try toUnicodePass("\xea\x96\xa8.16.3\xed\x88\x92\xdb\xb3", "\xea\x96\xa8.16.3\xed\x88\x92\xdb\xb3"); }
607test { try toUnicodePass("\xea\x96\xa8.16.3\xe1\x84\x90\xe1\x85\xad\xe1\x86\xa9\xdb\xb3", "\xea\x96\xa8.16.3\xed\x88\x92\xdb\xb3"); }
608test { try toUnicodePass("xn--1-5bt6845n.", "1\xf0\x9d\xa8\x99\xe2\xb8\x96."); }
609test { try toUnicodePass("1\xf0\x9d\xa8\x99\xe2\xb8\x96.", "1\xf0\x9d\xa8\x99\xe2\xb8\x96."); }
610test { try toUnicodePass("xn--ss-f4j.b.", "ss\xe1\x80\xba.b."); }
611test { try toUnicodePass("ss\xe1\x80\xba.b.", "ss\xe1\x80\xba.b."); }
612test { try toUnicodePass("SS\xe1\x80\xba.B.", "ss\xe1\x80\xba.b."); }
613test { try toUnicodePass("Ss\xe1\x80\xba.b.", "ss\xe1\x80\xba.b."); }
614test { try toUnicodePass("SS\xe1\x80\xba.b.", "ss\xe1\x80\xba.b."); }
615test { try toUnicodePass("\xdb\x8c\xf0\x90\xa8\xbf\xef\xbc\x8e\xc3\x9f\xe0\xbe\x84\xf0\x91\x8d\xac", "\xdb\x8c\xf0\x90\xa8\xbf.\xc3\x9f\xe0\xbe\x84\xf0\x91\x8d\xac"); }
616test { try toUnicodePass("\xdb\x8c\xf0\x90\xa8\xbf.\xc3\x9f\xe0\xbe\x84\xf0\x91\x8d\xac", "\xdb\x8c\xf0\x90\xa8\xbf.\xc3\x9f\xe0\xbe\x84\xf0\x91\x8d\xac"); }
617test { try toUnicodePass("\xdb\x8c\xf0\x90\xa8\xbf.SS\xe0\xbe\x84\xf0\x91\x8d\xac", "\xdb\x8c\xf0\x90\xa8\xbf.ss\xe0\xbe\x84\xf0\x91\x8d\xac"); }
618test { try toUnicodePass("\xdb\x8c\xf0\x90\xa8\xbf.ss\xe0\xbe\x84\xf0\x91\x8d\xac", "\xdb\x8c\xf0\x90\xa8\xbf.ss\xe0\xbe\x84\xf0\x91\x8d\xac"); }
619test { try toUnicodePass("xn--clb2593k.xn--ss-toj6092t", "\xdb\x8c\xf0\x90\xa8\xbf.ss\xe0\xbe\x84\xf0\x91\x8d\xac"); }
620test { try toUnicodePass("xn--clb2593k.xn--zca216edt0r", "\xdb\x8c\xf0\x90\xa8\xbf.\xc3\x9f\xe0\xbe\x84\xf0\x91\x8d\xac"); }
621test { try toUnicodePass("\xdb\x8c\xf0\x90\xa8\xbf\xef\xbc\x8eSS\xe0\xbe\x84\xf0\x91\x8d\xac", "\xdb\x8c\xf0\x90\xa8\xbf.ss\xe0\xbe\x84\xf0\x91\x8d\xac"); }
622test { try toUnicodePass("\xdb\x8c\xf0\x90\xa8\xbf\xef\xbc\x8ess\xe0\xbe\x84\xf0\x91\x8d\xac", "\xdb\x8c\xf0\x90\xa8\xbf.ss\xe0\xbe\x84\xf0\x91\x8d\xac"); }
623test { try toUnicodePass("\xdb\x8c\xf0\x90\xa8\xbf.Ss\xe0\xbe\x84\xf0\x91\x8d\xac", "\xdb\x8c\xf0\x90\xa8\xbf.ss\xe0\xbe\x84\xf0\x91\x8d\xac"); }
624test { try toUnicodePass("\xdb\x8c\xf0\x90\xa8\xbf\xef\xbc\x8eSs\xe0\xbe\x84\xf0\x91\x8d\xac", "\xdb\x8c\xf0\x90\xa8\xbf.ss\xe0\xbe\x84\xf0\x91\x8d\xac"); }
625test { try toUnicodePass("xn--8-ngo.", "8\xe2\x89\xae."); }
626test { try toUnicodePass("8\xe2\x89\xae.", "8\xe2\x89\xae."); }
627test { try toUnicodePass("8<\xcc\xb8.", "8\xe2\x89\xae."); }
628test { try toUnicodePass("\xe7\xbe\x9a\xef\xbd\xa1\xe2\x89\xaf", "\xe7\xbe\x9a.\xe2\x89\xaf"); }
629test { try toUnicodePass("\xe7\xbe\x9a\xef\xbd\xa1>\xcc\xb8", "\xe7\xbe\x9a.\xe2\x89\xaf"); }
630test { try toUnicodePass("\xe7\xbe\x9a\xe3\x80\x82\xe2\x89\xaf", "\xe7\xbe\x9a.\xe2\x89\xaf"); }
631test { try toUnicodePass("\xe7\xbe\x9a\xe3\x80\x82>\xcc\xb8", "\xe7\xbe\x9a.\xe2\x89\xaf"); }
632test { try toUnicodePass("xn--xt0a.xn--hdh", "\xe7\xbe\x9a.\xe2\x89\xaf"); }
633test { try toUnicodePass("\xe7\xbe\x9a.\xe2\x89\xaf", "\xe7\xbe\x9a.\xe2\x89\xaf"); }
634test { try toUnicodePass("\xe7\xbe\x9a.>\xcc\xb8", "\xe7\xbe\x9a.\xe2\x89\xaf"); }
635test { try toUnicodePass("xn--ye6h", "\xf0\x9e\xa4\xba"); }
636test { try toUnicodePass("\xf0\x9e\xa4\xba", "\xf0\x9e\xa4\xba"); }
637test { try toUnicodePass("\xf0\x9e\xa4\x98", "\xf0\x9e\xa4\xba"); }
638test { try toUnicodePass("\xf0\x9d\x9f\x9b\xef\xbc\x8e\xef\xa7\xb8", "3.\xe7\xac\xa0"); }
639test { try toUnicodePass("\xf0\x9d\x9f\x9b\xef\xbc\x8e\xe7\xac\xa0", "3.\xe7\xac\xa0"); }
640test { try toUnicodePass("3.\xe7\xac\xa0", "3.\xe7\xac\xa0"); }
641test { try toUnicodePass("3.xn--6vz", "3.\xe7\xac\xa0"); }
642test { try toUnicodePass("xn--1ch.", "\xe2\x89\xa0."); }
643test { try toUnicodePass("\xe2\x89\xa0.", "\xe2\x89\xa0."); }
644test { try toUnicodePass("=\xcc\xb8.", "\xe2\x89\xa0."); }
645test { try toUnicodePass("f", "f"); }
646test { try toUnicodePass("xn--9bm.ss", "\xe3\xa8\xb2.ss"); }
647test { try toUnicodePass("\xe3\xa8\xb2.ss", "\xe3\xa8\xb2.ss"); }
648test { try toUnicodePass("\xe3\xa8\xb2.SS", "\xe3\xa8\xb2.ss"); }
649test { try toUnicodePass("\xe3\xa8\xb2.Ss", "\xe3\xa8\xb2.ss"); }
650test { try toUnicodePass("\xf0\x9d\x9f\x8e\xe3\x80\x82\xe7\x94\xaf", "0.\xe7\x94\xaf"); }
651test { try toUnicodePass("0\xe3\x80\x82\xe7\x94\xaf", "0.\xe7\x94\xaf"); }
652test { try toUnicodePass("0.xn--qny", "0.\xe7\x94\xaf"); }
653test { try toUnicodePass("0.\xe7\x94\xaf", "0.\xe7\x94\xaf"); }
654test { try toUnicodePass("\xf0\x9f\x82\xb4\xe1\x82\xab.\xe2\x89\xae", "\xf0\x9f\x82\xb4\xe2\xb4\x8b.\xe2\x89\xae"); }
655test { try toUnicodePass("\xf0\x9f\x82\xb4\xe1\x82\xab.<\xcc\xb8", "\xf0\x9f\x82\xb4\xe2\xb4\x8b.\xe2\x89\xae"); }
656test { try toUnicodePass("\xf0\x9f\x82\xb4\xe2\xb4\x8b.<\xcc\xb8", "\xf0\x9f\x82\xb4\xe2\xb4\x8b.\xe2\x89\xae"); }
657test { try toUnicodePass("\xf0\x9f\x82\xb4\xe2\xb4\x8b.\xe2\x89\xae", "\xf0\x9f\x82\xb4\xe2\xb4\x8b.\xe2\x89\xae"); }
658test { try toUnicodePass("xn--2kj7565l.xn--gdh", "\xf0\x9f\x82\xb4\xe2\xb4\x8b.\xe2\x89\xae"); }
659test { try toUnicodePass("xn--gky8837e.", "\xe7\x92\xbc\xf0\x9d\xa8\xad."); }
660test { try toUnicodePass("\xe7\x92\xbc\xf0\x9d\xa8\xad.", "\xe7\x92\xbc\xf0\x9d\xa8\xad."); }
661test { try toUnicodePass("xn--157b.xn--gnb", "\xed\x8a\x9b.\xdc\x96"); }
662test { try toUnicodePass("\xed\x8a\x9b.\xdc\x96", "\xed\x8a\x9b.\xdc\x96"); }
663test { try toUnicodePass("\xe1\x84\x90\xe1\x85\xb1\xe1\x87\x82.\xdc\x96", "\xed\x8a\x9b.\xdc\x96"); }
664test { try toUnicodePass("xn--84-s850a.xn--59h6326e", "84\xf0\x9d\x88\xbb.\xf0\x90\x8b\xb5\xe2\x9b\xa7"); }
665test { try toUnicodePass("84\xf0\x9d\x88\xbb.\xf0\x90\x8b\xb5\xe2\x9b\xa7", "84\xf0\x9d\x88\xbb.\xf0\x90\x8b\xb5\xe2\x9b\xa7"); }
666test { try toUnicodePass("\xe2\x89\xae\xf0\x9d\x9f\x95\xef\xbc\x8e\xe8\xac\x96\xc3\x9f\xe2\x89\xaf", "\xe2\x89\xae7.\xe8\xac\x96\xc3\x9f\xe2\x89\xaf"); }
667test { try toUnicodePass("<\xcc\xb8\xf0\x9d\x9f\x95\xef\xbc\x8e\xe8\xac\x96\xc3\x9f>\xcc\xb8", "\xe2\x89\xae7.\xe8\xac\x96\xc3\x9f\xe2\x89\xaf"); }
668test { try toUnicodePass("\xe2\x89\xae7.\xe8\xac\x96\xc3\x9f\xe2\x89\xaf", "\xe2\x89\xae7.\xe8\xac\x96\xc3\x9f\xe2\x89\xaf"); }
669test { try toUnicodePass("<\xcc\xb87.\xe8\xac\x96\xc3\x9f>\xcc\xb8", "\xe2\x89\xae7.\xe8\xac\x96\xc3\x9f\xe2\x89\xaf"); }
670test { try toUnicodePass("<\xcc\xb87.\xe8\xac\x96SS>\xcc\xb8", "\xe2\x89\xae7.\xe8\xac\x96ss\xe2\x89\xaf"); }
671test { try toUnicodePass("\xe2\x89\xae7.\xe8\xac\x96SS\xe2\x89\xaf", "\xe2\x89\xae7.\xe8\xac\x96ss\xe2\x89\xaf"); }
672test { try toUnicodePass("\xe2\x89\xae7.\xe8\xac\x96ss\xe2\x89\xaf", "\xe2\x89\xae7.\xe8\xac\x96ss\xe2\x89\xaf"); }
673test { try toUnicodePass("<\xcc\xb87.\xe8\xac\x96ss>\xcc\xb8", "\xe2\x89\xae7.\xe8\xac\x96ss\xe2\x89\xaf"); }
674test { try toUnicodePass("<\xcc\xb87.\xe8\xac\x96Ss>\xcc\xb8", "\xe2\x89\xae7.\xe8\xac\x96ss\xe2\x89\xaf"); }
675test { try toUnicodePass("\xe2\x89\xae7.\xe8\xac\x96Ss\xe2\x89\xaf", "\xe2\x89\xae7.\xe8\xac\x96ss\xe2\x89\xaf"); }
676test { try toUnicodePass("xn--7-mgo.xn--ss-xjvv174c", "\xe2\x89\xae7.\xe8\xac\x96ss\xe2\x89\xaf"); }
677test { try toUnicodePass("xn--7-mgo.xn--zca892oly5e", "\xe2\x89\xae7.\xe8\xac\x96\xc3\x9f\xe2\x89\xaf"); }
678test { try toUnicodePass("<\xcc\xb8\xf0\x9d\x9f\x95\xef\xbc\x8e\xe8\xac\x96SS>\xcc\xb8", "\xe2\x89\xae7.\xe8\xac\x96ss\xe2\x89\xaf"); }
679test { try toUnicodePass("\xe2\x89\xae\xf0\x9d\x9f\x95\xef\xbc\x8e\xe8\xac\x96SS\xe2\x89\xaf", "\xe2\x89\xae7.\xe8\xac\x96ss\xe2\x89\xaf"); }
680test { try toUnicodePass("\xe2\x89\xae\xf0\x9d\x9f\x95\xef\xbc\x8e\xe8\xac\x96ss\xe2\x89\xaf", "\xe2\x89\xae7.\xe8\xac\x96ss\xe2\x89\xaf"); }
681test { try toUnicodePass("<\xcc\xb8\xf0\x9d\x9f\x95\xef\xbc\x8e\xe8\xac\x96ss>\xcc\xb8", "\xe2\x89\xae7.\xe8\xac\x96ss\xe2\x89\xaf"); }
682test { try toUnicodePass("<\xcc\xb8\xf0\x9d\x9f\x95\xef\xbc\x8e\xe8\xac\x96Ss>\xcc\xb8", "\xe2\x89\xae7.\xe8\xac\x96ss\xe2\x89\xaf"); }
683test { try toUnicodePass("\xe2\x89\xae\xf0\x9d\x9f\x95\xef\xbc\x8e\xe8\xac\x96Ss\xe2\x89\xaf", "\xe2\x89\xae7.\xe8\xac\x96ss\xe2\x89\xaf"); }
684test { try toUnicodePass("xn--ss-bh7o", "ss\xf0\x91\x93\x83"); }
685test { try toUnicodePass("ss\xf0\x91\x93\x83", "ss\xf0\x91\x93\x83"); }
686test { try toUnicodePass("SS\xf0\x91\x93\x83", "ss\xf0\x91\x93\x83"); }
687test { try toUnicodePass("Ss\xf0\x91\x93\x83", "ss\xf0\x91\x93\x83"); }
688test { try toUnicodePass("xn--qekw60d.xn--gd9a", "\xe3\x83\xb6\xe4\x92\xa9.\xea\xa1\xaa"); }
689test { try toUnicodePass("\xe3\x83\xb6\xe4\x92\xa9.\xea\xa1\xaa", "\xe3\x83\xb6\xe4\x92\xa9.\xea\xa1\xaa"); }
690test { try toUnicodePass("xn--8c1a.xn--2ib8jn539l", "\xe8\x88\x9b.\xd9\xbd\xf0\x9e\xa4\xb4\xda\xbb"); }
691test { try toUnicodePass("\xe8\x88\x9b.\xd9\xbd\xf0\x9e\xa4\xb4\xda\xbb", "\xe8\x88\x9b.\xd9\xbd\xf0\x9e\xa4\xb4\xda\xbb"); }
692test { try toUnicodePass("\xe8\x88\x9b.\xd9\xbd\xf0\x9e\xa4\x92\xda\xbb", "\xe8\x88\x9b.\xd9\xbd\xf0\x9e\xa4\xb4\xda\xbb"); }
693test { try toUnicodePass("xn--hcb32bni", "\xda\xbd\xd9\xa3\xd6\x96"); }
694test { try toUnicodePass("\xda\xbd\xd9\xa3\xd6\x96", "\xda\xbd\xd9\xa3\xd6\x96"); }
695test { try toUnicodePass("xn--8gb2338k.xn--lhb0154f", "\xd8\xbd\xf0\x91\x88\xbe.\xd9\x89\xea\xa4\xab"); }
696test { try toUnicodePass("\xd8\xbd\xf0\x91\x88\xbe.\xd9\x89\xea\xa4\xab", "\xd8\xbd\xf0\x91\x88\xbe.\xd9\x89\xea\xa4\xab"); }
697test { try toUnicodePass("\xe1\x83\x81\xe1\x82\xb16\xcc\x98\xe3\x80\x82\xc3\x9f\xe1\xac\x83", "\xe2\xb4\xa1\xe2\xb4\x916\xcc\x98.\xc3\x9f\xe1\xac\x83"); }
698test { try toUnicodePass("\xe2\xb4\xa1\xe2\xb4\x916\xcc\x98\xe3\x80\x82\xc3\x9f\xe1\xac\x83", "\xe2\xb4\xa1\xe2\xb4\x916\xcc\x98.\xc3\x9f\xe1\xac\x83"); }
699test { try toUnicodePass("\xe1\x83\x81\xe1\x82\xb16\xcc\x98\xe3\x80\x82SS\xe1\xac\x83", "\xe2\xb4\xa1\xe2\xb4\x916\xcc\x98.ss\xe1\xac\x83"); }
700test { try toUnicodePass("\xe2\xb4\xa1\xe2\xb4\x916\xcc\x98\xe3\x80\x82ss\xe1\xac\x83", "\xe2\xb4\xa1\xe2\xb4\x916\xcc\x98.ss\xe1\xac\x83"); }
701test { try toUnicodePass("\xe1\x83\x81\xe2\xb4\x916\xcc\x98\xe3\x80\x82Ss\xe1\xac\x83", "\xe2\xb4\xa1\xe2\xb4\x916\xcc\x98.ss\xe1\xac\x83"); }
702test { try toUnicodePass("xn--6-8cb7433a2ba.xn--ss-2vq", "\xe2\xb4\xa1\xe2\xb4\x916\xcc\x98.ss\xe1\xac\x83"); }
703test { try toUnicodePass("\xe2\xb4\xa1\xe2\xb4\x916\xcc\x98.ss\xe1\xac\x83", "\xe2\xb4\xa1\xe2\xb4\x916\xcc\x98.ss\xe1\xac\x83"); }
704test { try toUnicodePass("\xe1\x83\x81\xe1\x82\xb16\xcc\x98.SS\xe1\xac\x83", "\xe2\xb4\xa1\xe2\xb4\x916\xcc\x98.ss\xe1\xac\x83"); }
705test { try toUnicodePass("\xe1\x83\x81\xe2\xb4\x916\xcc\x98.Ss\xe1\xac\x83", "\xe2\xb4\xa1\xe2\xb4\x916\xcc\x98.ss\xe1\xac\x83"); }
706test { try toUnicodePass("xn--6-8cb7433a2ba.xn--zca894k", "\xe2\xb4\xa1\xe2\xb4\x916\xcc\x98.\xc3\x9f\xe1\xac\x83"); }
707test { try toUnicodePass("\xe2\xb4\xa1\xe2\xb4\x916\xcc\x98.\xc3\x9f\xe1\xac\x83", "\xe2\xb4\xa1\xe2\xb4\x916\xcc\x98.\xc3\x9f\xe1\xac\x83"); }
708test { try toUnicodePass("xn--7zv.", "\xe6\xa2\x89."); }
709test { try toUnicodePass("\xe6\xa2\x89.", "\xe6\xa2\x89."); }
710test { try toUnicodePass("xn--iwb.ss", "\xe0\xa1\x93.ss"); }
711test { try toUnicodePass("\xe0\xa1\x93.ss", "\xe0\xa1\x93.ss"); }
712test { try toUnicodePass("\xe0\xa1\x93.SS", "\xe0\xa1\x93.ss"); }
713test { try toUnicodePass("xn--ix9c26l.xn--q0s", "\xf0\x90\xab\x9c\xf0\x91\x8c\xbc.\xe5\xa9\x80"); }
714test { try toUnicodePass("\xf0\x90\xab\x9c\xf0\x91\x8c\xbc.\xe5\xa9\x80", "\xf0\x90\xab\x9c\xf0\x91\x8c\xbc.\xe5\xa9\x80"); }
715test { try toUnicodePass("\xf0\x90\xab\x80\xef\xbc\x8e\xda\x89\xf0\x91\x8c\x80", "\xf0\x90\xab\x80.\xda\x89\xf0\x91\x8c\x80"); }
716test { try toUnicodePass("\xf0\x90\xab\x80.\xda\x89\xf0\x91\x8c\x80", "\xf0\x90\xab\x80.\xda\x89\xf0\x91\x8c\x80"); }
717test { try toUnicodePass("xn--pw9c.xn--fjb8658k", "\xf0\x90\xab\x80.\xda\x89\xf0\x91\x8c\x80"); }
718test { try toUnicodePass("xn--r97c.", "\xf0\x90\x8b\xb7."); }
719test { try toUnicodePass("\xf0\x90\x8b\xb7.", "\xf0\x90\x8b\xb7."); }
zigmod.yml+4
......@@ -4,3 +4,7 @@ main: idna.zig
44license: MIT
55description: "UTS #46"
66dependencies:
7 - src: git https://github.com/nektro/zig-extras
8 - src: git https://github.com/nektro/zig-unicode-ucd
9root_dependencies:
10 - src: git https://github.com/nektro/zig-expect