language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-28 06:14:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

fix zig tests

Browse source
This commit is contained in:
Folkert 2020-12-03 17:20:08 +01:00
parent 3162ab5fc4
commit e8583a72fb
1 changed files with 100 additions and 142 deletions
Download patch file Download diff file Expand all files Collapse all files

242
compiler/builtins/bitcode/src/str.zig
View file

@ -86,17 +86,15 @@ const RocStr = extern struct {
return false; return false;
} }
const self_bytes_nonnull: [*]const u8 = self_bytes_ptr orelse unreachable;
const other_bytes_nonnull: [*]const u8 = other_bytes_ptr orelse unreachable;
const self_u8_ptr: [*]const u8 = @ptrCast([*]const u8, &self); const self_u8_ptr: [*]const u8 = @ptrCast([*]const u8, &self);
const other_u8_ptr: [*]const u8 = @ptrCast([*]const u8, &other); const other_u8_ptr: [*]const u8 = @ptrCast([*]const u8, &other);
const self_bytes: [*]const u8 = if (self.is_small_str()) self_u8_ptr else self_bytes_nonnull; const self_bytes: [*]const u8 = if (self.is_small_str() or self.is_empty()) self_u8_ptr else self_bytes_ptr orelse unreachable;
const other_bytes: [*]const u8 = if (other.is_small_str()) other_u8_ptr else other_bytes_nonnull; const other_bytes: [*]const u8 = if (other.is_small_str() or other.is_empty()) other_u8_ptr else other_bytes_ptr orelse unreachable;
var index: usize = 0; var index: usize = 0;
// TODO rewrite this into a for loop // TODO rewrite this into a for loop
while (index < self.str_len) { while (index < self.len()) {
if (self_bytes[index] != other_bytes[index]) { if (self_bytes[index] != other_bytes[index]) {
return false; return false;
} }
@ -206,7 +204,7 @@ const RocStr = extern struct {
} }
}; };
// Str.len // Str.numberOfBytes
pub fn strLen(string: RocStr) callconv(.C) u64 { pub fn strLen(string: RocStr) callconv(.C) u64 {
return string.len(); return string.len();
@ -261,24 +259,23 @@ pub fn strSplitInPlace(array: [*]RocStr, array_len: usize, string: RocStr, delim
test "strSplitInPlace: no delimiter" { test "strSplitInPlace: no delimiter" {
// Str.split "abc" "!" == [ "abc" ] // Str.split "abc" "!" == [ "abc" ]
var str: [3]u8 = "abc".*; const str_arr = "abc";
const str_ptr: [*]const u8 = &str; const str = RocStr.init(str_arr, str_arr.len);
var delimiter: [1]u8 = "!".*; const delimiter_arr = "!";
const delimiter_ptr: [*]const u8 = &delimiter; const delimiter = RocStr.init(delimiter_arr, delimiter_arr.len);
var array: [1]RocStr = undefined; var array: [1]RocStr = undefined;
const array_ptr: [*]RocStr = &array; const array_ptr: [*]RocStr = &array;
strSplitInPlace(array_ptr, 1, str_ptr, 3, delimiter_ptr, 1); strSplitInPlace(array_ptr, 1, str, delimiter);
var expected = [1]RocStr{ var expected = [1]RocStr{
RocStr.init(str_ptr, 3), str,
}; };
expectEqual(array.len, expected.len); expectEqual(array.len, expected.len);
// TODO: fix those tests expect(array[0].eq(expected[0]));
//expect(array[0].eq(expected[0]));
for (array) |roc_str| { for (array) |roc_str| {
roc_str.drop(); roc_str.drop();
@ -290,13 +287,11 @@ test "strSplitInPlace: no delimiter" {
} }
test "strSplitInPlace: empty end" { test "strSplitInPlace: empty end" {
const str_len: usize = 50; const str_arr = "1---- ---- ---- ---- ----2---- ---- ---- ---- ----";
var str: [str_len]u8 = "1---- ---- ---- ---- ----2---- ---- ---- ---- ----".*; const str = RocStr.init(str_arr, str_arr.len);
const str_ptr: [*]u8 = &str;
const delimiter_len = 24; const delimiter_arr = "---- ---- ---- ---- ----";
const delimiter: [delimiter_len:0]u8 = "---- ---- ---- ---- ----".*; const delimiter = RocStr.init(delimiter_arr, delimiter_arr.len);
const delimiter_ptr: [*]const u8 = &delimiter;
const array_len: usize = 3; const array_len: usize = 3;
var array: [array_len]RocStr = [_]RocStr{ var array: [array_len]RocStr = [_]RocStr{
@ -306,35 +301,27 @@ test "strSplitInPlace: empty end" {
}; };
const array_ptr: [*]RocStr = &array; const array_ptr: [*]RocStr = &array;
strSplitInPlace(array_ptr, array_len, str_ptr, str_len, delimiter_ptr, delimiter_len); strSplitInPlace(array_ptr, array_len, str, delimiter);
const first_expected_str_len: usize = 1; const one = RocStr.init("1", 1);
var first_expected_str: [first_expected_str_len]u8 = "1".*; const two = RocStr.init("2", 1);
const first_expected_str_ptr: [*]u8 = &first_expected_str;
var firstExpectedRocStr = RocStr.init(first_expected_str_ptr, first_expected_str_len);
const second_expected_str_len: usize = 1; var expected = [3]RocStr{
var second_expected_str: [second_expected_str_len]u8 = "2".*; one, two, RocStr.empty(),
const second_expected_str_ptr: [*]u8 = &second_expected_str; };
var secondExpectedRocStr = RocStr.init(second_expected_str_ptr, second_expected_str_len);
// TODO: fix those tests expectEqual(array.len, expected.len);
// expectEqual(array.len, 3); expect(array[0].eq(expected[0]));
// expectEqual(array[0].str_len, 1); expect(array[1].eq(expected[1]));
// expect(array[0].eq(firstExpectedRocStr)); expect(array[2].eq(expected[2]));
// expect(array[1].eq(secondExpectedRocStr));
// expectEqual(array[2].str_len, 0);
} }
test "strSplitInPlace: delimiter on sides" { test "strSplitInPlace: delimiter on sides" {
// Str.split "tttghittt" "ttt" == [ "", "ghi", "" ] const str_arr = "tttghittt";
const str_len: usize = 9; const str = RocStr.init(str_arr, str_arr.len);
var str: [str_len]u8 = "tttghittt".*;
const str_ptr: [*]u8 = &str;
const delimiter_len = 3; const delimiter_arr = "ttt";
var delimiter: [delimiter_len]u8 = "ttt".*; const delimiter = RocStr.init(delimiter_arr, delimiter_arr.len);
const delimiter_ptr: [*]u8 = &delimiter;
const array_len: usize = 3; const array_len: usize = 3;
var array: [array_len]RocStr = [_]RocStr{ var array: [array_len]RocStr = [_]RocStr{
@ -343,66 +330,47 @@ test "strSplitInPlace: delimiter on sides" {
undefined, undefined,
}; };
const array_ptr: [*]RocStr = &array; const array_ptr: [*]RocStr = &array;
strSplitInPlace(array_ptr, array_len, str, delimiter);
strSplitInPlace(array_ptr, array_len, str_ptr, str_len, delimiter_ptr, delimiter_len); const ghi_arr = "ghi";
const ghi = RocStr.init(ghi_arr, ghi_arr.len);
const expected_str_len: usize = 3; var expected = [3]RocStr{
var expected_str: [expected_str_len]u8 = "ghi".*; RocStr.empty(), ghi, RocStr.empty(),
const expected_str_ptr: [*]const u8 = &expected_str; };
var expectedRocStr = RocStr.init(expected_str_ptr, expected_str_len);
// TODO: fix those tests expectEqual(array.len, expected.len);
// expectEqual(array.len, 3); expect(array[0].eq(expected[0]));
// expectEqual(array[0].str_len, 0); expect(array[1].eq(expected[1]));
// expect(array[1].eq(expectedRocStr)); expect(array[2].eq(expected[2]));
// expectEqual(array[2].str_len, 0);
} }
test "strSplitInPlace: three pieces" { test "strSplitInPlace: three pieces" {
// Str.split "a!b!c" "!" == [ "a", "b", "c" ] // Str.split "a!b!c" "!" == [ "a", "b", "c" ]
const str_len: usize = 5; const str_arr = "a!b!c";
var str: [str_len]u8 = "a!b!c".*; const str = RocStr.init(str_arr, str_arr.len);
const str_ptr: [*]u8 = &str;
const delimiter_len = 1; const delimiter_arr = "!";
var delimiter: [delimiter_len]u8 = "!".*; const delimiter = RocStr.init(delimiter_arr, delimiter_arr.len);
const delimiter_ptr: [*]u8 = &delimiter;
const array_len: usize = 3; const array_len: usize = 3;
var array: [array_len]RocStr = undefined; var array: [array_len]RocStr = undefined;
const array_ptr: [*]RocStr = &array; const array_ptr: [*]RocStr = &array;
strSplitInPlace(array_ptr, array_len, str_ptr, str_len, delimiter_ptr, delimiter_len); strSplitInPlace(array_ptr, array_len, str, delimiter);
var a: [1]u8 = "a".*; const a = RocStr.init("a", 1);
const a_ptr: [*]u8 = &a; const b = RocStr.init("b", 1);
const c = RocStr.init("c", 1);
var b: [1]u8 = "b".*;
const b_ptr: [*]u8 = &b;
var c: [1]u8 = "c".*;
const c_ptr: [*]u8 = &c;
var expected_array = [array_len]RocStr{ var expected_array = [array_len]RocStr{
RocStr{ a, b, c,
.str_bytes = a_ptr,
.str_len = 1,
},
RocStr{
.str_bytes = b_ptr,
.str_len = 1,
},
RocStr{
.str_bytes = c_ptr,
.str_len = 1,
},
}; };
// TODO: fix those tests expectEqual(expected_array.len, array.len);
// expectEqual(expected_array.len, array.len); expect(array[0].eq(expected_array[0]));
// expect(array[0].eq(expected_array[0])); expect(array[1].eq(expected_array[1]));
// expect(array[1].eq(expected_array[1])); expect(array[2].eq(expected_array[2]));
// expect(array[2].eq(expected_array[2]));
} }
// This is used for `Str.split : Str, Str -> Array Str // This is used for `Str.split : Str, Str -> Array Str
@ -453,15 +421,13 @@ pub fn countSegments(string: RocStr, delimiter: RocStr) callconv(.C) usize {
test "countSegments: long delimiter" { test "countSegments: long delimiter" {
// Str.split "str" "delimiter" == [ "str" ] // Str.split "str" "delimiter" == [ "str" ]
// 1 segment // 1 segment
const str_len: usize = 3; const str_arr = "str";
var str: [str_len]u8 = "str".*; const str = RocStr.init(str_arr, str_arr.len);
const str_ptr: [*]u8 = &str;
const delimiter_len = 9; const delimiter_arr = "delimiter";
var delimiter: [delimiter_len]u8 = "delimiter".*; const delimiter = RocStr.init(delimiter_arr, delimiter_arr.len);
const delimiter_ptr: [*]u8 = &delimiter;
const segments_count = countSegments(str_ptr, str_len, delimiter_ptr, delimiter_len); const segments_count = countSegments(str, delimiter);
expectEqual(segments_count, 1); expectEqual(segments_count, 1);
} }
@ -469,15 +435,13 @@ test "countSegments: long delimiter" {
test "countSegments: delimiter at start" { test "countSegments: delimiter at start" {
// Str.split "hello there" "hello" == [ "", " there" ] // Str.split "hello there" "hello" == [ "", " there" ]
// 2 segments // 2 segments
const str_len: usize = 11; const str_arr = "hello there";
var str: [str_len]u8 = "hello there".*; const str = RocStr.init(str_arr, str_arr.len);
const str_ptr: [*]u8 = &str;
const delimiter_len = 5; const delimiter_arr = "hello";
var delimiter: [delimiter_len]u8 = "hello".*; const delimiter = RocStr.init(delimiter_arr, delimiter_arr.len);
const delimiter_ptr: [*]u8 = &delimiter;
const segments_count = countSegments(str_ptr, str_len, delimiter_ptr, delimiter_len); const segments_count = countSegments(str, delimiter);
expectEqual(segments_count, 2); expectEqual(segments_count, 2);
} }
@ -485,15 +449,13 @@ test "countSegments: delimiter at start" {
test "countSegments: delimiter interspered" { test "countSegments: delimiter interspered" {
// Str.split "a!b!c" "!" == [ "a", "b", "c" ] // Str.split "a!b!c" "!" == [ "a", "b", "c" ]
// 3 segments // 3 segments
const str_len: usize = 5; const str_arr = "a!b!c";
var str: [str_len]u8 = "a!b!c".*; const str = RocStr.init(str_arr, str_arr.len);
const str_ptr: [*]u8 = &str;
const delimiter_len = 1; const delimiter_arr = "!";
var delimiter: [delimiter_len]u8 = "!".*; const delimiter = RocStr.init(delimiter_arr, delimiter_arr.len);
const delimiter_ptr: [*]u8 = &delimiter;
const segments_count = countSegments(str_ptr, str_len, delimiter_ptr, delimiter_len); const segments_count = countSegments(str, delimiter);
expectEqual(segments_count, 3); expectEqual(segments_count, 3);
} }
@ -502,6 +464,10 @@ test "countSegments: delimiter interspered" {
const grapheme = @import("helpers/grapheme.zig"); const grapheme = @import("helpers/grapheme.zig");
pub fn countGraphemeClusters(string: RocStr) callconv(.C) usize { pub fn countGraphemeClusters(string: RocStr) callconv(.C) usize {
if (string.is_empty()) {
return 0;
}
const bytes_len = string.len(); const bytes_len = string.len();
const bytes_ptr = string.as_u8_ptr(); const bytes_ptr = string.as_u8_ptr();
@ -532,51 +498,45 @@ pub fn countGraphemeClusters(string: RocStr) callconv(.C) usize {
return count; return count;
} }
fn roc_str_from_literal(bytes_arr: *const []u8) RocStr {}
test "countGraphemeClusters: empty string" { test "countGraphemeClusters: empty string" {
var bytes_arr = "".*; const count = countGraphemeClusters(RocStr.empty());
var bytes_len = bytes_arr.len;
var bytes_ptr: [*]u8 = &bytes_arr;
var count = countGraphemeClusters(bytes_ptr, bytes_len);
expectEqual(count, 0); expectEqual(count, 0);
} }
test "countGraphemeClusters: ascii characters" { test "countGraphemeClusters: ascii characters" {
var bytes_arr = "abcd".*; const bytes_arr = "abcd";
var bytes_len = bytes_arr.len; const bytes_len = bytes_arr.len;
var bytes_ptr: [*]u8 = &bytes_arr; const count = countGraphemeClusters(RocStr.init(bytes_arr, bytes_len));
var count = countGraphemeClusters(bytes_ptr, bytes_len);
expectEqual(count, 4); expectEqual(count, 4);
} }
test "countGraphemeClusters: utf8 characters" { test "countGraphemeClusters: utf8 characters" {
var bytes_arr = "ãxā".*; const bytes_arr = "ãxā";
var bytes_len = bytes_arr.len; const bytes_len = bytes_arr.len;
var bytes_ptr: [*]u8 = &bytes_arr; const count = countGraphemeClusters(RocStr.init(bytes_arr, bytes_len));
var count = countGraphemeClusters(bytes_ptr, bytes_len);
expectEqual(count, 3); expectEqual(count, 3);
} }
test "countGraphemeClusters: emojis" { test "countGraphemeClusters: emojis" {
var bytes_arr = "🤔🤔🤔".*; const bytes_arr = "🤔🤔🤔";
var bytes_len = bytes_arr.len; const bytes_len = bytes_arr.len;
var bytes_ptr: [*]u8 = &bytes_arr; const count = countGraphemeClusters(RocStr.init(bytes_arr, bytes_len));
var count = countGraphemeClusters(bytes_ptr, bytes_len);
expectEqual(count, 3); expectEqual(count, 3);
} }
test "countGraphemeClusters: emojis and ut8 characters" { test "countGraphemeClusters: emojis and ut8 characters" {
var bytes_arr = "🤔å🤔¥🤔ç".*; const bytes_arr = "🤔å🤔¥🤔ç";
var bytes_len = bytes_arr.len; const bytes_len = bytes_arr.len;
var bytes_ptr: [*]u8 = &bytes_arr; const count = countGraphemeClusters(RocStr.init(bytes_arr, bytes_len));
var count = countGraphemeClusters(bytes_ptr, bytes_len);
expectEqual(count, 6); expectEqual(count, 6);
} }
test "countGraphemeClusters: emojis, ut8, and ascii characters" { test "countGraphemeClusters: emojis, ut8, and ascii characters" {
var bytes_arr = "6🤔å🤔e¥🤔çpp".*; const bytes_arr = "6🤔å🤔e¥🤔çpp";
var bytes_len = bytes_arr.len; const bytes_len = bytes_arr.len;
var bytes_ptr: [*]u8 = &bytes_arr; const count = countGraphemeClusters(RocStr.init(bytes_arr, bytes_len));
var count = countGraphemeClusters(bytes_ptr, bytes_len);
expectEqual(count, 10); expectEqual(count, 10);
} }
@ -604,24 +564,22 @@ pub fn startsWith(string: RocStr, prefix: RocStr) callconv(.C) bool {
return true; return true;
} }
test "startsWith: 123456789123456789 starts with 123456789123456789" { test "startsWith: foo starts with fo" {
const str_len: usize = 18; const foo = RocStr.init("foo", 3);
var str: [str_len]u8 = "123456789123456789".*; const fo = RocStr.init("fo", 2);
const str_ptr: [*]u8 = &str; expect(startsWith(foo, fo));
}
expect(startsWith(str_ptr, str_len, str_ptr, str_len)); test "startsWith: 123456789123456789 starts with 123456789123456789" {
const str = RocStr.init("123456789123456789", 18);
expect(startsWith(str, str));
} }
test "startsWith: 12345678912345678910 starts with 123456789123456789" { test "startsWith: 12345678912345678910 starts with 123456789123456789" {
const str_len: usize = 20; const str = RocStr.init("12345678912345678910", 20);
var str: [str_len]u8 = "12345678912345678910".*; const prefix = RocStr.init("123456789123456789", 18);
const str_ptr: [*]u8 = &str;
const prefix_len: usize = 18; expect(startsWith(str, prefix));
var prefix: [prefix_len]u8 = "123456789123456789".*;
const prefix_ptr: [*]u8 = &str;
expect(startsWith(str_ptr, str_len, prefix_ptr, prefix_len));
} }
// Str.split // Str.split