string: rename string type to nstr_t
This might annoy a bunch of people, but it kinda follows the "traditional" C coding style and i like it more. Also it reminds you that strings are absolutely not a primitive data type.
This commit is contained in:
parent
cb09acbc7c
commit
c797540dbc
GPG key ID:
EC22E476DC2D3D84
27 changed files with 208 additions and 208 deletions
include
src
test
|
|
@ -13,9 +13,9 @@ extern "C" {
|
|||
#include "neo/_error.h"
|
||||
#include "neo/_nbuf.h"
|
||||
#include "neo/_nref.h"
|
||||
#include "neo/_nstr.h"
|
||||
#include "neo/_types.h"
|
||||
#include "neo/_stddef.h"
|
||||
#include "neo/_string.h"
|
||||
#include "neo/_nalloc.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@
|
|||
* the values to insert which will become the error message.
|
||||
*/
|
||||
__attribute__(( __format__(printf, 3, 4) ))
|
||||
void yeet(error *err, u32 number, const char *__restrict fmt, ...);
|
||||
void yeet(error *err, u32 number, const char *restrict fmt, ...);
|
||||
|
||||
/**
|
||||
* Indicate an operation has completed successfully.
|
||||
|
|
@ -62,7 +62,7 @@ void errput(error *err);
|
|||
* Get an optional error message, this may be `nil`
|
||||
* Must only be used within a catch block and before `errput` is called.
|
||||
*/
|
||||
#define errmsg(err) ((err) == nil ? (string *)nil : (err)->_message)
|
||||
#define errmsg(err) ((err) == nil ? (nstr_t *)nil : (err)->_message)
|
||||
|
||||
/*
|
||||
* This file is part of libneo.
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@
|
|||
* `src/string/nstr.c` for details.
|
||||
*/
|
||||
struct _neo_nstr_init_info {
|
||||
string **dest;
|
||||
nstr_t **dest;
|
||||
const char *data;
|
||||
};
|
||||
|
||||
|
|
@ -25,7 +25,7 @@ struct _neo_nstr_init_info {
|
|||
* @param content: A `const char *` with the contents of the string
|
||||
*/
|
||||
#define NSTR_DEFINE(name, content) \
|
||||
string *name = nil; \
|
||||
nstr_t *name = nil; \
|
||||
__neo_section(.data.__neo.nstr_array) \
|
||||
struct _neo_nstr_init_info __neo_nstr_init_info_##name = { \
|
||||
.dest = &name, \
|
||||
|
|
@ -43,7 +43,7 @@ struct _neo_nstr_init_info {
|
|||
* @param err: Error pointer
|
||||
* @returns The converted string, unless an error occurred
|
||||
*/
|
||||
string *nstr(const char *restrict s, error *err);
|
||||
nstr_t *nstr(const char *restrict s, error *err);
|
||||
|
||||
/**
|
||||
* Copy a regular C string to a neo string, but at most `maxsize` bytes.
|
||||
|
|
@ -57,7 +57,7 @@ string *nstr(const char *restrict s, error *err);
|
|||
* @param err: Error pointer
|
||||
* @returns The converted string, unless an error occurred
|
||||
*/
|
||||
string *nnstr(const char *restrict s, usize maxsize, error *err);
|
||||
nstr_t *nnstr(const char *restrict s, usize maxsize, error *err);
|
||||
|
||||
/**
|
||||
* Get the Unicode code point in a string at the specified index.
|
||||
|
|
@ -70,7 +70,7 @@ string *nnstr(const char *restrict s, usize maxsize, error *err);
|
|||
* @returns The Unicode code point at the specified index,
|
||||
* unless an error occurred
|
||||
*/
|
||||
nchar nchrat(const string *s, usize index, error *err);
|
||||
nchar nchrat(const nstr_t *s, usize index, error *err);
|
||||
|
||||
/**
|
||||
* Convert a signed integer to a string.
|
||||
|
|
@ -82,7 +82,7 @@ nchar nchrat(const string *s, usize index, error *err);
|
|||
* @param err: Error pointer
|
||||
* @returns The stringified integer, unless an error occurred
|
||||
*/
|
||||
string *i2nstr(i64 i, int radix, error *err);
|
||||
nstr_t *i2nstr(i64 i, int radix, error *err);
|
||||
|
||||
/**
|
||||
* Convert an unsigned integer to a string.
|
||||
|
|
@ -94,7 +94,7 @@ string *i2nstr(i64 i, int radix, error *err);
|
|||
* @param err: Error pointer
|
||||
* @returns The stringified integer, unless an error occurred
|
||||
*/
|
||||
string *u2nstr(u64 u, int radix, error *err);
|
||||
nstr_t *u2nstr(u64 u, int radix, error *err);
|
||||
|
||||
/**
|
||||
* Duplicate a string.
|
||||
|
|
@ -106,7 +106,7 @@ string *u2nstr(u64 u, int radix, error *err);
|
|||
* @param err: Error pointer
|
||||
* @returns The duplicated string, unless an error occurred
|
||||
*/
|
||||
string *nstrdup(const string *s, error *err);
|
||||
nstr_t *nstrdup(const nstr_t *s, error *err);
|
||||
|
||||
/**
|
||||
* Repeat a string `n` times and return the new string.
|
||||
|
|
@ -120,7 +120,7 @@ string *nstrdup(const string *s, error *err);
|
|||
* @param err: Error pointer
|
||||
* @returns A new string with the repeated content, unless an error occurred
|
||||
*/
|
||||
string *nstrmul(const string *s, usize n, error *err);
|
||||
nstr_t *nstrmul(const nstr_t *s, usize n, error *err);
|
||||
|
||||
/**
|
||||
* Create a string considting of `n` repetitions of `c`.
|
||||
|
|
@ -133,7 +133,7 @@ string *nstrmul(const string *s, usize n, error *err);
|
|||
* @param err: Error pointer
|
||||
* @returns The string, unless an error occurred
|
||||
*/
|
||||
string *nchrmul(nchar c, usize n, error *err);
|
||||
nstr_t *nchrmul(nchar c, usize n, error *err);
|
||||
|
||||
/**
|
||||
* Concatenate two strings and return the result.
|
||||
|
|
@ -147,7 +147,7 @@ string *nchrmul(nchar c, usize n, error *err);
|
|||
* @returns A new string instance that consists of the two concatenated ones,
|
||||
* unless an error occurred
|
||||
*/
|
||||
string *nstrcat(const string *s1, const string *s2, error *err);
|
||||
nstr_t *nstrcat(const nstr_t *s1, const nstr_t *s2, error *err);
|
||||
|
||||
/**
|
||||
* Compare two strings character by character.
|
||||
|
|
@ -159,7 +159,7 @@ string *nstrcat(const string *s1, const string *s2, error *err);
|
|||
* @param err: Error pointer
|
||||
* @returns The difference between the two strings, unless an error occurred
|
||||
*/
|
||||
int nstrcmp(const string *s1, const string *s2, error *err);
|
||||
int nstrcmp(const nstr_t *s1, const nstr_t *s2, error *err);
|
||||
|
||||
/**
|
||||
* Determine whether two strings are exactly equal.
|
||||
|
|
@ -185,7 +185,7 @@ int nstrcmp(const string *s1, const string *s2, error *err);
|
|||
* @param err: Error pointer
|
||||
* @returns The new padded string
|
||||
*/
|
||||
string *leftpad(const string *s, usize length, nchar fill, error *err);
|
||||
nstr_t *leftpad(const nstr_t *s, usize length, nchar fill, error *err);
|
||||
|
||||
/**
|
||||
* Iterate over each character in a string.
|
||||
|
|
@ -74,7 +74,7 @@ struct _neo_nbuf {
|
|||
*/
|
||||
typedef struct _neo_nbuf nbuf_t;
|
||||
|
||||
struct _neo_string {
|
||||
struct _neo_nstr {
|
||||
/* The *amount of Unicode code points*, NOT amount of bytes */
|
||||
NLEN_FIELD(_len);
|
||||
NREF_FIELD;
|
||||
|
|
@ -82,10 +82,10 @@ struct _neo_string {
|
|||
usize _size;
|
||||
char *_data;
|
||||
};
|
||||
typedef struct _neo_string string;
|
||||
typedef struct _neo_nstr nstr_t;
|
||||
|
||||
struct _neo_error {
|
||||
string *_message;
|
||||
nstr_t *_message;
|
||||
u32 _number;
|
||||
};
|
||||
typedef struct _neo_error error;
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ extern "C" {
|
|||
* @returns The number of UTF-8 code points (i.e. number of Unicode characters)
|
||||
* excluding the terminating NUL byte; undefined on error
|
||||
*/
|
||||
usize utf8_check(const char *__restrict s, error *err);
|
||||
usize utf8_check(const char *restrict s, error *err);
|
||||
|
||||
/**
|
||||
* Check whether a NUL terminated string is valid UTF-8, but read at most
|
||||
|
|
@ -49,7 +49,7 @@ usize utf8_check(const char *__restrict s, error *err);
|
|||
* @returns The number of UTF-8 code points (i.e. number of Unicode characters)
|
||||
* excluding the terminating NUL byte; undefined on error
|
||||
*/
|
||||
usize utf8_ncheck(const char *__restrict s, usize maxsize, error *err);
|
||||
usize utf8_ncheck(const char *restrict s, usize maxsize, error *err);
|
||||
|
||||
/**
|
||||
* Compute the length of a raw UTF-8 encoded, NUL terminated string.
|
||||
|
|
@ -61,7 +61,7 @@ usize utf8_ncheck(const char *__restrict s, usize maxsize, error *err);
|
|||
* @returns: String length as in Unicode code points (not bytes),
|
||||
* excluding the terminating NUL byte
|
||||
*/
|
||||
usize utf8_strlen(const char *__restrict s);
|
||||
usize utf8_strlen(const char *restrict s);
|
||||
|
||||
/**
|
||||
* Get the amount of bytes a Unicode character takes up in UTF-8.
|
||||
|
|
@ -89,7 +89,7 @@ usize utf8_chrsize(nchar c, error *err);
|
|||
* @returns The amount of bytes taken up by the character,
|
||||
* which is always between 1 and 4 except on errors
|
||||
*/
|
||||
usize utf8_from_nchr(char *__restrict dest, nchar c, error *err);
|
||||
usize utf8_from_nchr(char *restrict dest, nchar c, error *err);
|
||||
|
||||
/**
|
||||
* Decode a UTF-8 character and store it in `c`.
|
||||
|
|
@ -107,7 +107,7 @@ usize utf8_from_nchr(char *__restrict dest, nchar c, error *err);
|
|||
* @returns The amount of bytes the character took up when encoded as UTF-8,
|
||||
* which is always between 1 and 4 except on errors
|
||||
*/
|
||||
usize utf8_to_nchr(nchar *c, const char *__restrict utf8chr, error *err);
|
||||
usize utf8_to_nchr(nchar *c, const char *restrict utf8chr, error *err);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}; /* extern "C" */
|
||||
|
|
|
|||
|
|
@ -9,8 +9,8 @@
|
|||
#include "neo/_error.h"
|
||||
#include "neo/_nalloc.h"
|
||||
#include "neo/_nref.h"
|
||||
#include "neo/_nstr.h"
|
||||
#include "neo/_stddef.h"
|
||||
#include "neo/_string.h"
|
||||
#include "neo/_types.h"
|
||||
|
||||
void yeet(error *err, u32 number, const char *restrict fmt, ...)
|
||||
|
|
|
|||
|
|
@ -6,11 +6,11 @@
|
|||
#include "neo/_error.h"
|
||||
#include "neo/_nalloc.h"
|
||||
#include "neo/_nref.h"
|
||||
#include "neo/_string.h"
|
||||
#include "neo/_nstr.h"
|
||||
#include "neo/_types.h"
|
||||
#include "neo/utf.h"
|
||||
|
||||
static inline string *leftpad_unsafe(const string *s, usize len, nchar fillchr, error *err)
|
||||
static inline nstr_t *leftpad_unsafe(const nstr_t *s, usize len, nchar fillchr, error *err)
|
||||
{
|
||||
char utf8_fillchr[5];
|
||||
usize fillchr_size = utf8_from_nchr(&utf8_fillchr[0], fillchr, err);
|
||||
|
|
@ -39,7 +39,7 @@ static inline string *leftpad_unsafe(const string *s, usize len, nchar fillchr,
|
|||
}
|
||||
strcpy(pos, s->_data);
|
||||
|
||||
string *padded = nstr(dest, err);
|
||||
nstr_t *padded = nstr(dest, err);
|
||||
catch(err) {
|
||||
padded = nil;
|
||||
}
|
||||
|
|
@ -47,14 +47,14 @@ static inline string *leftpad_unsafe(const string *s, usize len, nchar fillchr,
|
|||
return padded;
|
||||
}
|
||||
|
||||
string *leftpad(const string *s, usize len, nchar fillchr, error *err)
|
||||
nstr_t *leftpad(const nstr_t *s, usize len, nchar fillchr, error *err)
|
||||
{
|
||||
if (s == nil) {
|
||||
yeet(err, EFAULT, "String is nil");
|
||||
return 0;
|
||||
}
|
||||
|
||||
string *padded;
|
||||
nstr_t *padded;
|
||||
|
||||
if (len < nlen(s)) {
|
||||
yeet(err, ERANGE, "String is longer than requested length");
|
||||
|
|
|
|||
|
|
@ -9,25 +9,25 @@
|
|||
#include "neo/_error.h"
|
||||
#include "neo/_nalloc.h"
|
||||
#include "neo/_nref.h"
|
||||
#include "neo/_string.h"
|
||||
#include "neo/_nstr.h"
|
||||
#include "neo/_toolchain.h"
|
||||
#include "neo/_types.h"
|
||||
#include "neo/utf.h"
|
||||
|
||||
static void nstr_destroy(string *str)
|
||||
static void nstr_destroy(nstr_t *str)
|
||||
{
|
||||
nfree(str->_data);
|
||||
nfree(str);
|
||||
}
|
||||
|
||||
static string *nstr_unsafe(const char *restrict s, usize size_without_nul, error *err)
|
||||
static nstr_t *nstr_unsafe(const char *restrict s, usize size_without_nul, error *err)
|
||||
{
|
||||
usize len = utf8_ncheck(s, size_without_nul, err);
|
||||
catch(err) {
|
||||
return nil;
|
||||
}
|
||||
|
||||
string *str = nalloc(sizeof(*str), err);
|
||||
nstr_t *str = nalloc(sizeof(*str), err);
|
||||
catch(err) {
|
||||
return nil;
|
||||
}
|
||||
|
|
@ -64,7 +64,7 @@ static string *nstr_unsafe(const char *restrict s, usize size_without_nul, error
|
|||
return str;
|
||||
}
|
||||
|
||||
string *nstr(const char *restrict s, error *err)
|
||||
nstr_t *nstr(const char *restrict s, error *err)
|
||||
{
|
||||
if (s == nil) {
|
||||
yeet(err, EFAULT, "String is nil");
|
||||
|
|
@ -75,7 +75,7 @@ string *nstr(const char *restrict s, error *err)
|
|||
return nstr_unsafe(s, size_without_nul, err);
|
||||
}
|
||||
|
||||
string *nnstr(const char *restrict s, usize maxsize, error *err)
|
||||
nstr_t *nnstr(const char *restrict s, usize maxsize, error *err)
|
||||
{
|
||||
if (s == nil) {
|
||||
yeet(err, EFAULT, "String is nil");
|
||||
|
|
@ -86,7 +86,7 @@ string *nnstr(const char *restrict s, usize maxsize, error *err)
|
|||
return nstr_unsafe(s, size_without_nul, err);
|
||||
}
|
||||
|
||||
nchar nchrat(const string *s, usize index, error *err)
|
||||
nchar nchrat(const nstr_t *s, usize index, error *err)
|
||||
{
|
||||
if (s == nil) {
|
||||
yeet(err, EFAULT, "String is nil");
|
||||
|
|
|
|||
|
|
@ -9,11 +9,11 @@
|
|||
#include "neo/_error.h"
|
||||
#include "neo/_nalloc.h"
|
||||
#include "neo/_nref.h"
|
||||
#include "neo/_nstr.h"
|
||||
#include "neo/_stddef.h"
|
||||
#include "neo/_string.h"
|
||||
#include "neo/_types.h"
|
||||
|
||||
string *nstrcat(const string *s1, const string *s2, error *err)
|
||||
nstr_t *nstrcat(const nstr_t *s1, const nstr_t *s2, error *err)
|
||||
{
|
||||
if (s1 == nil) {
|
||||
yeet(err, EFAULT, "First string is nil");
|
||||
|
|
@ -36,7 +36,7 @@ string *nstrcat(const string *s1, const string *s2, error *err)
|
|||
memcpy(cat + s1_size_without_nul, s2->_data, s2_size_without_nul);
|
||||
cat[s1_size_without_nul + s2_size_without_nul] = '\0';
|
||||
|
||||
string *ret = nstr(cat, err);
|
||||
nstr_t *ret = nstr(cat, err);
|
||||
nfree(cat);
|
||||
return ret;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,11 +5,11 @@
|
|||
|
||||
#include "neo/_error.h"
|
||||
#include "neo/_nref.h"
|
||||
#include "neo/_nstr.h"
|
||||
#include "neo/_stddef.h"
|
||||
#include "neo/_string.h"
|
||||
#include "neo/_types.h"
|
||||
|
||||
int nstrcmp(const string *s1, const string *s2, error *err)
|
||||
int nstrcmp(const nstr_t *s1, const nstr_t *s2, error *err)
|
||||
{
|
||||
/*
|
||||
* Return values are always undefined if an error was yeeted so it's not
|
||||
|
|
|
|||
|
|
@ -3,10 +3,10 @@
|
|||
#include <errno.h>
|
||||
|
||||
#include "neo/_error.h"
|
||||
#include "neo/_string.h"
|
||||
#include "neo/_nstr.h"
|
||||
#include "neo/_types.h"
|
||||
|
||||
string *nstrdup(const string *s, error *err)
|
||||
nstr_t *nstrdup(const nstr_t *s, error *err)
|
||||
{
|
||||
if (s == nil) {
|
||||
yeet(err, EFAULT, "String is nil");
|
||||
|
|
|
|||
|
|
@ -6,12 +6,12 @@
|
|||
#include "neo/_error.h"
|
||||
#include "neo/_nalloc.h"
|
||||
#include "neo/_nref.h"
|
||||
#include "neo/_nstr.h"
|
||||
#include "neo/_stddef.h"
|
||||
#include "neo/_string.h"
|
||||
#include "neo/_types.h"
|
||||
#include "neo/utf.h"
|
||||
|
||||
string *nstrmul(const string *s, usize n, error *err)
|
||||
nstr_t *nstrmul(const nstr_t *s, usize n, error *err)
|
||||
{
|
||||
if (s == nil) {
|
||||
yeet(err, EFAULT, "String is nil");
|
||||
|
|
@ -34,12 +34,12 @@ string *nstrmul(const string *s, usize n, error *err)
|
|||
pos += s_size;
|
||||
}
|
||||
|
||||
string *ret = nstr(multiplied, err);
|
||||
nstr_t *ret = nstr(multiplied, err);
|
||||
nfree(multiplied);
|
||||
return ret;
|
||||
}
|
||||
|
||||
string *nchrmul(nchar c, usize n, error *err)
|
||||
nstr_t *nchrmul(nchar c, usize n, error *err)
|
||||
{
|
||||
if (n == 0)
|
||||
return nstr("", err);
|
||||
|
|
@ -61,7 +61,7 @@ string *nchrmul(nchar c, usize n, error *err)
|
|||
pos += s_size;
|
||||
}
|
||||
|
||||
string *ret = nstr(multiplied, err);
|
||||
nstr_t *ret = nstr(multiplied, err);
|
||||
nfree(multiplied);
|
||||
return ret;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
#include <errno.h>
|
||||
|
||||
#include "neo/_error.h"
|
||||
#include "neo/_string.h"
|
||||
#include "neo/_nstr.h"
|
||||
#include "neo/_types.h"
|
||||
|
||||
static char *unsigned_convert(char *end, u64 n, int radix, error *err)
|
||||
|
|
@ -31,7 +31,7 @@ static char *unsigned_convert(char *end, u64 n, int radix, error *err)
|
|||
return end;
|
||||
}
|
||||
|
||||
string *u2nstr(u64 n, int radix, error *err)
|
||||
nstr_t *u2nstr(u64 n, int radix, error *err)
|
||||
{
|
||||
char buf[65];
|
||||
char *s = unsigned_convert(&buf[64], n, radix, err);
|
||||
|
|
@ -41,7 +41,7 @@ string *u2nstr(u64 n, int radix, error *err)
|
|||
return nstr(s, err);
|
||||
}
|
||||
|
||||
string *i2nstr(i64 n, int radix, error *err)
|
||||
nstr_t *i2nstr(i64 n, int radix, error *err)
|
||||
{
|
||||
char buf[66];
|
||||
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ TEST_CASE( "nbuf_create: Error if size is 0", "[src/nbuf.c]" )
|
|||
{
|
||||
error err;
|
||||
nbuf_t *buf = nbuf_create(0, &err);
|
||||
string *expected_msg = nstr("Cannot create zero-size buffer", nil);
|
||||
nstr_t *expected_msg = nstr("Cannot create zero-size buffer", nil);
|
||||
|
||||
REQUIRE( buf == nil );
|
||||
REQUIRE( errnum(&err) == ERANGE );
|
||||
|
|
@ -49,7 +49,7 @@ TEST_CASE( "nbuf_from: Error if data is nil", "[src/nbuf.c]" )
|
|||
error err;
|
||||
nbuf_t *buf = nbuf_from(nil, 1, &err);
|
||||
|
||||
string *expected_msg = nstr("Data is nil", nil);
|
||||
nstr_t *expected_msg = nstr("Data is nil", nil);
|
||||
|
||||
REQUIRE( buf == nil );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
@ -65,7 +65,7 @@ TEST_CASE( "nbuf_from: Error if size is 0", "[src/nbuf.c]" )
|
|||
const char *data = "i'm gay,,,";
|
||||
nbuf_t *buf = nbuf_from(data, 0, &err);
|
||||
|
||||
string *expected_msg = nstr("Cannot create zero-size buffer", nil);
|
||||
nstr_t *expected_msg = nstr("Cannot create zero-size buffer", nil);
|
||||
|
||||
REQUIRE( buf == nil );
|
||||
REQUIRE( errnum(&err) == ERANGE );
|
||||
|
|
@ -98,7 +98,7 @@ TEST_CASE( "nbuf_clone: Error if original buffer is nil", "[src/nbuf.c]" )
|
|||
error err;
|
||||
nbuf_t *buf = nbuf_clone(nil, &err);
|
||||
|
||||
string *expected_msg = nstr("Source buffer is nil", nil);
|
||||
nstr_t *expected_msg = nstr("Source buffer is nil", nil);
|
||||
|
||||
REQUIRE( buf == nil );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
@ -171,7 +171,7 @@ TEST_CASE( "nbuf_cmp: Error if first buffer is nil", "[src/nbuf.c]" )
|
|||
nbuf_t *buf2 = nbuf_from(data, size, nil);
|
||||
int diff = nbuf_cmp(nil, buf2, &err);
|
||||
|
||||
string *expected_msg = nstr("First buffer is nil", nil);
|
||||
nstr_t *expected_msg = nstr("First buffer is nil", nil);
|
||||
|
||||
REQUIRE( diff < 0 );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
@ -190,7 +190,7 @@ TEST_CASE( "nbuf_cmp: Error if second buffer is nil", "[src/nbuf.c]" )
|
|||
nbuf_t *buf1 = nbuf_from(data, size, nil);
|
||||
int diff = nbuf_cmp(buf1, nil, &err);
|
||||
|
||||
string *expected_msg = nstr("Second buffer is nil", nil);
|
||||
nstr_t *expected_msg = nstr("Second buffer is nil", nil);
|
||||
|
||||
REQUIRE( diff > 0 );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
@ -206,7 +206,7 @@ TEST_CASE( "nbuf_cmp: Error if both buffers are nil", "[src/nbuf.c]" )
|
|||
|
||||
int diff = nbuf_cmp(nil, nil, &err);
|
||||
|
||||
string *expected_msg = nstr("First buffer is nil", nil);
|
||||
nstr_t *expected_msg = nstr("First buffer is nil", nil);
|
||||
|
||||
REQUIRE( diff == 0 );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
|
|||
|
|
@ -9,8 +9,8 @@ TEST_CASE( "i2nstr: Convert 0 to base 2", "[string/x2nstr.c]" )
|
|||
{
|
||||
error err;
|
||||
|
||||
string *expected = nstr("0", nil);
|
||||
string *actual = i2nstr(0, 2, &err);
|
||||
nstr_t *expected = nstr("0", nil);
|
||||
nstr_t *actual = i2nstr(0, 2, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -24,8 +24,8 @@ TEST_CASE( "i2nstr: Convert 0 to base 36", "[string/x2nstr.c]" )
|
|||
{
|
||||
error err;
|
||||
|
||||
string *expected = nstr("0", nil);
|
||||
string *actual = i2nstr(0, 36, &err);
|
||||
nstr_t *expected = nstr("0", nil);
|
||||
nstr_t *actual = i2nstr(0, 36, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -39,8 +39,8 @@ TEST_CASE( "i2nstr: Convert 255 to base 2", "[string/x2nstr.c]" )
|
|||
{
|
||||
error err;
|
||||
|
||||
string *expected = nstr("11111111", nil);
|
||||
string *actual = i2nstr(255, 2, &err);
|
||||
nstr_t *expected = nstr("11111111", nil);
|
||||
nstr_t *actual = i2nstr(255, 2, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -54,8 +54,8 @@ TEST_CASE( "i2nstr: Convert -255 to base 2", "[string/x2nstr.c]" )
|
|||
{
|
||||
error err;
|
||||
|
||||
string *expected = nstr("-11111111", nil);
|
||||
string *actual = i2nstr(-255, 2, &err);
|
||||
nstr_t *expected = nstr("-11111111", nil);
|
||||
nstr_t *actual = i2nstr(-255, 2, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -69,8 +69,8 @@ TEST_CASE( "i2nstr: Convert 1679615 to base 36", "[string/x2nstr.c]" )
|
|||
{
|
||||
error err;
|
||||
|
||||
string *expected = nstr("zzzz", nil);
|
||||
string *actual = i2nstr(1679615, 36, &err);
|
||||
nstr_t *expected = nstr("zzzz", nil);
|
||||
nstr_t *actual = i2nstr(1679615, 36, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -84,8 +84,8 @@ TEST_CASE( "i2nstr: Convert -1679615 to base 36", "[string/x2nstr.c]" )
|
|||
{
|
||||
error err;
|
||||
|
||||
string *expected = nstr("-zzzz", nil);
|
||||
string *actual = i2nstr(-1679615, 36, &err);
|
||||
nstr_t *expected = nstr("-zzzz", nil);
|
||||
nstr_t *actual = i2nstr(-1679615, 36, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -99,8 +99,8 @@ TEST_CASE( "i2nstr: Convert 2^63-1 to base 16", "[string/x2nstr.c]" )
|
|||
{
|
||||
error err;
|
||||
|
||||
string *expected = nstr("7fffffffffffffff", nil);
|
||||
string *actual = i2nstr(0x7fffffffffffffff, 16, &err);
|
||||
nstr_t *expected = nstr("7fffffffffffffff", nil);
|
||||
nstr_t *actual = i2nstr(0x7fffffffffffffff, 16, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -114,8 +114,8 @@ TEST_CASE( "i2nstr: Convert -2^63 to base 16", "[string/x2nstr.c]" )
|
|||
{
|
||||
error err;
|
||||
|
||||
string *expected = nstr("-8000000000000000", nil);
|
||||
string *actual = i2nstr(-0x8000000000000000, 16, &err);
|
||||
nstr_t *expected = nstr("-8000000000000000", nil);
|
||||
nstr_t *actual = i2nstr(-0x8000000000000000, 16, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -128,10 +128,10 @@ TEST_CASE( "i2nstr: Convert -2^63 to base 16", "[string/x2nstr.c]" )
|
|||
TEST_CASE( "i2nstr: Error if base too low", "[string/x2nstr.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s = i2nstr(420, 1, &err);
|
||||
nstr_t *s = i2nstr(420, 1, &err);
|
||||
|
||||
string *expected_msg = nstr("Numerical base out of range", nil);
|
||||
string *actual_msg = errmsg(&err);
|
||||
nstr_t *expected_msg = nstr("Numerical base out of range", nil);
|
||||
nstr_t *actual_msg = errmsg(&err);
|
||||
|
||||
REQUIRE( s == nil );
|
||||
REQUIRE( nstreq(expected_msg, actual_msg, nil) );
|
||||
|
|
@ -144,10 +144,10 @@ TEST_CASE( "i2nstr: Error if base too low", "[string/x2nstr.c]" )
|
|||
TEST_CASE( "i2nstr: Error if base too high", "[string/x2nstr.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s = i2nstr(420, 37, &err);
|
||||
nstr_t *s = i2nstr(420, 37, &err);
|
||||
|
||||
string *expected_msg = nstr("Numerical base out of range", nil);
|
||||
string *actual_msg = errmsg(&err);
|
||||
nstr_t *expected_msg = nstr("Numerical base out of range", nil);
|
||||
nstr_t *actual_msg = errmsg(&err);
|
||||
|
||||
REQUIRE( s == nil );
|
||||
REQUIRE( nstreq(expected_msg, actual_msg, nil) );
|
||||
|
|
|
|||
|
|
@ -8,10 +8,10 @@
|
|||
TEST_CASE( "leftpad: Pad a string with ASCII character", "[string/leftpad.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s = nstr("i'm gay,,,", nil);
|
||||
nstr_t *s = nstr("i'm gay,,,", nil);
|
||||
|
||||
string *expected = nstr(",,,i'm gay,,,", nil);
|
||||
string *actual = leftpad(s, 13, ',', &err);
|
||||
nstr_t *expected = nstr(",,,i'm gay,,,", nil);
|
||||
nstr_t *actual = leftpad(s, 13, ',', &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nlen(actual) == 13 );
|
||||
|
|
@ -26,10 +26,10 @@ TEST_CASE( "leftpad: Pad a string with ASCII character", "[string/leftpad.c]" )
|
|||
TEST_CASE( "leftpad: Pad a string with UTF-8 character", "[string/leftpad.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s = nstr("i'm gay,,,", nil);
|
||||
nstr_t *s = nstr("i'm gay,,,", nil);
|
||||
|
||||
string *expected = nstr("\xf0\x9f\xa5\xba\xf0\x9f\xa5\xbai'm gay,,,", nil);
|
||||
string *actual = leftpad(s, 12, 0x01f97a, &err);
|
||||
nstr_t *expected = nstr("\xf0\x9f\xa5\xba\xf0\x9f\xa5\xbai'm gay,,,", nil);
|
||||
nstr_t *actual = leftpad(s, 12, 0x01f97a, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nlen(actual) == 12 );
|
||||
|
|
@ -44,9 +44,9 @@ TEST_CASE( "leftpad: Pad a string with UTF-8 character", "[string/leftpad.c]" )
|
|||
TEST_CASE( "leftpad: Duplicate if string is expected length", "[string/leftpad.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s = nstr("i'm gay,,,", nil);
|
||||
nstr_t *s = nstr("i'm gay,,,", nil);
|
||||
|
||||
string *padded = leftpad(s, 10, ',', &err);
|
||||
nstr_t *padded = leftpad(s, 10, ',', &err);
|
||||
|
||||
REQUIRE( padded != nil );
|
||||
REQUIRE( nlen(padded) == 10 );
|
||||
|
|
@ -60,9 +60,9 @@ TEST_CASE( "leftpad: Duplicate if string is expected length", "[string/leftpad.c
|
|||
TEST_CASE( "leftpad: Error if string is nil", "[string/leftpad.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s = leftpad(nil, 10, ',', &err);
|
||||
nstr_t *s = leftpad(nil, 10, ',', &err);
|
||||
|
||||
string *expected_msg = nstr("String is nil", nil);
|
||||
nstr_t *expected_msg = nstr("String is nil", nil);
|
||||
|
||||
REQUIRE( s == nil );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
@ -75,10 +75,10 @@ TEST_CASE( "leftpad: Error if string is nil", "[string/leftpad.c]" )
|
|||
TEST_CASE( "leftpad: Error if string is too long", "[string/leftpad.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s = nstr("i'm gay,,,", nil);
|
||||
string *padded = leftpad(s, 9, ',', &err);
|
||||
nstr_t *s = nstr("i'm gay,,,", nil);
|
||||
nstr_t *padded = leftpad(s, 9, ',', &err);
|
||||
|
||||
string *expected_msg = nstr("String is longer than requested length", nil);
|
||||
nstr_t *expected_msg = nstr("String is longer than requested length", nil);
|
||||
|
||||
REQUIRE( padded == nil );
|
||||
REQUIRE( errnum(&err) == ERANGE );
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
TEST_CASE( "nstr: Create a string", "[string/nstr.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s = nstr("i'm gay,,,", &err);
|
||||
nstr_t *s = nstr("i'm gay,,,", &err);
|
||||
|
||||
REQUIRE( s != nil );
|
||||
REQUIRE( nlen(s) == 10 );
|
||||
|
|
@ -21,10 +21,10 @@ TEST_CASE( "nstr: Create a string", "[string/nstr.c]" )
|
|||
TEST_CASE( "nstr: Error if raw strig is nil", "[string/nstr,c]")
|
||||
{
|
||||
error err;
|
||||
string *s = nstr(nil, &err);
|
||||
nstr_t *s = nstr(nil, &err);
|
||||
|
||||
string *expected = nstr("String is nil", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("String is nil", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( s == nil );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
@ -36,7 +36,7 @@ TEST_CASE( "nnstr: Create a string", "[string/nstr.c]" )
|
|||
{
|
||||
error err;
|
||||
/* 10 character string, must be truncated */
|
||||
string *s = nnstr("i'm gay,,,", 8, &err);
|
||||
nstr_t *s = nnstr("i'm gay,,,", 8, &err);
|
||||
|
||||
REQUIRE( s != nil );
|
||||
REQUIRE( nlen(s) == 8 );
|
||||
|
|
@ -49,10 +49,10 @@ TEST_CASE( "nnstr: Create a string", "[string/nstr.c]" )
|
|||
TEST_CASE( "nnstr: Error if raw strig is nil", "[string/nstr,c]")
|
||||
{
|
||||
error err;
|
||||
string *s = nnstr(nil, 10, &err);
|
||||
nstr_t *s = nnstr(nil, 10, &err);
|
||||
|
||||
string *expected = nstr("String is nil", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("String is nil", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( s == nil );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
@ -64,7 +64,7 @@ NSTR_DEFINE(static_test_string_1, "i'm gay,,,");
|
|||
|
||||
TEST_CASE( "_neo_nstr_init_array: Statically initialize ASCII string", "[string/nstr.c]" )
|
||||
{
|
||||
string *expected_s1 = nstr("i'm gay,,,", nil);
|
||||
nstr_t *expected_s1 = nstr("i'm gay,,,", nil);
|
||||
|
||||
REQUIRE( nstreq(expected_s1, static_test_string_1, nil) );
|
||||
REQUIRE( nlen(static_test_string_1) == 10 );
|
||||
|
|
@ -74,7 +74,7 @@ NSTR_DEFINE(static_test_string_2, "i'm gay\xf0\x9f\xa5\xba,,,");
|
|||
|
||||
TEST_CASE( "_neo_nstr_init_array: Statically initialize UTF-8 string", "[string/nstr.c]" )
|
||||
{
|
||||
string *expected_s2 = nstr("i'm gay\xf0\x9f\xa5\xba,,,", nil);
|
||||
nstr_t *expected_s2 = nstr("i'm gay\xf0\x9f\xa5\xba,,,", nil);
|
||||
|
||||
REQUIRE( nstreq(expected_s2, static_test_string_2, nil) );
|
||||
REQUIRE( nlen(static_test_string_2) == 11 );
|
||||
|
|
|
|||
|
|
@ -8,10 +8,10 @@
|
|||
TEST_CASE( "nstrcat: Concatenate two strings", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s1 = nstr("i'm ", nil);
|
||||
string *s2 = nstr("gay,,,", nil);
|
||||
string *expected = nstr("i'm gay,,,", nil);
|
||||
string *actual = nstrcat(s1, s2, &err);
|
||||
nstr_t *s1 = nstr("i'm ", nil);
|
||||
nstr_t *s2 = nstr("gay,,,", nil);
|
||||
nstr_t *expected = nstr("i'm gay,,,", nil);
|
||||
nstr_t *actual = nstrcat(s1, s2, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nlen(actual) == 10 );
|
||||
|
|
@ -27,10 +27,10 @@ TEST_CASE( "nstrcat: Concatenate two strings", "[string/nstrcat.c]" )
|
|||
TEST_CASE( "nstrcat: Concatenate two UTF-8 strings", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s1 = nstr("i'm ", nil);
|
||||
string *s2 = nstr("gay\xf0\x9f\xa5\xba,,,", nil);
|
||||
string *expected = nstr("i'm gay\xf0\x9f\xa5\xba,,,", nil);
|
||||
string *actual = nstrcat(s1, s2, &err);
|
||||
nstr_t *s1 = nstr("i'm ", nil);
|
||||
nstr_t *s2 = nstr("gay\xf0\x9f\xa5\xba,,,", nil);
|
||||
nstr_t *expected = nstr("i'm gay\xf0\x9f\xa5\xba,,,", nil);
|
||||
nstr_t *actual = nstrcat(s1, s2, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nlen(actual) == 11 );
|
||||
|
|
@ -46,10 +46,10 @@ TEST_CASE( "nstrcat: Concatenate two UTF-8 strings", "[string/nstrcat.c]" )
|
|||
TEST_CASE( "nstrcat: Concatenate two empty strings", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s1 = nstr("", nil);
|
||||
string *s2 = nstr("", nil);
|
||||
string *expected = nstr("", nil);
|
||||
string *actual = nstrcat(s1, s2, &err);
|
||||
nstr_t *s1 = nstr("", nil);
|
||||
nstr_t *s2 = nstr("", nil);
|
||||
nstr_t *expected = nstr("", nil);
|
||||
nstr_t *actual = nstrcat(s1, s2, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nlen(actual) == 0 );
|
||||
|
|
@ -65,11 +65,11 @@ TEST_CASE( "nstrcat: Concatenate two empty strings", "[string/nstrcat.c]" )
|
|||
TEST_CASE( "nstrcat: Error if first string is nil", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s2 = nstr("", nil);
|
||||
string *cat = nstrcat(nil, s2, &err);
|
||||
nstr_t *s2 = nstr("", nil);
|
||||
nstr_t *cat = nstrcat(nil, s2, &err);
|
||||
|
||||
string *expected_msg = nstr("First string is nil", nil);
|
||||
string *actual_msg = errmsg(&err);
|
||||
nstr_t *expected_msg = nstr("First string is nil", nil);
|
||||
nstr_t *actual_msg = errmsg(&err);
|
||||
|
||||
REQUIRE( cat == nil );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
@ -83,11 +83,11 @@ TEST_CASE( "nstrcat: Error if first string is nil", "[string/nstrcat.c]" )
|
|||
TEST_CASE( "nstrcat: Error if second string is nil", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s1 = nstr("", nil);
|
||||
string *cat = nstrcat(s1, nil, &err);
|
||||
nstr_t *s1 = nstr("", nil);
|
||||
nstr_t *cat = nstrcat(s1, nil, &err);
|
||||
|
||||
string *expected_msg = nstr("Second string is nil", nil);
|
||||
string *actual_msg = errmsg(&err);
|
||||
nstr_t *expected_msg = nstr("Second string is nil", nil);
|
||||
nstr_t *actual_msg = errmsg(&err);
|
||||
|
||||
REQUIRE( cat == nil );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
|
|||
|
|
@ -8,8 +8,8 @@
|
|||
TEST_CASE( "nstrcmp: Return 0 if strings are equal", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s1 = nstr("aaaaa", nil);
|
||||
string *s2 = nstr("aaaaa", nil);
|
||||
nstr_t *s1 = nstr("aaaaa", nil);
|
||||
nstr_t *s2 = nstr("aaaaa", nil);
|
||||
|
||||
int diff = nstrcmp(s1, s2, &err);
|
||||
|
||||
|
|
@ -23,8 +23,8 @@ TEST_CASE( "nstrcmp: Return 0 if strings are equal", "[string/nstrcat.c]" )
|
|||
TEST_CASE( "nstrcmp: Return negative if first string is empty", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s1 = nstr("", nil);
|
||||
string *s2 = nstr("aaaaa", nil);
|
||||
nstr_t *s1 = nstr("", nil);
|
||||
nstr_t *s2 = nstr("aaaaa", nil);
|
||||
|
||||
int diff = nstrcmp(s1, s2, &err);
|
||||
|
||||
|
|
@ -38,8 +38,8 @@ TEST_CASE( "nstrcmp: Return negative if first string is empty", "[string/nstrcat
|
|||
TEST_CASE( "nstrcmp: Return positive if second string is empty", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s1 = nstr("aaaaa", nil);
|
||||
string *s2 = nstr("", nil);
|
||||
nstr_t *s1 = nstr("aaaaa", nil);
|
||||
nstr_t *s2 = nstr("", nil);
|
||||
|
||||
int diff = nstrcmp(s1, s2, &err);
|
||||
|
||||
|
|
@ -53,8 +53,8 @@ TEST_CASE( "nstrcmp: Return positive if second string is empty", "[string/nstrca
|
|||
TEST_CASE( "nstrcmp: Return 0 if both strings are empty", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s1 = nstr("", nil);
|
||||
string *s2 = nstr("", nil);
|
||||
nstr_t *s1 = nstr("", nil);
|
||||
nstr_t *s2 = nstr("", nil);
|
||||
|
||||
int diff = nstrcmp(s1, s2, &err);
|
||||
|
||||
|
|
@ -69,8 +69,8 @@ TEST_CASE( "nstrcmp: Return positive if first string is larger", "[string/nstrca
|
|||
{
|
||||
error err;
|
||||
/* 'a' has a higher ASCII value than 'A' */
|
||||
string *s1 = nstr("aaaaa", nil);
|
||||
string *s2 = nstr("aaaAa", nil);
|
||||
nstr_t *s1 = nstr("aaaaa", nil);
|
||||
nstr_t *s2 = nstr("aaaAa", nil);
|
||||
|
||||
int diff = nstrcmp(s1, s2, &err);
|
||||
|
||||
|
|
@ -85,8 +85,8 @@ TEST_CASE( "nstrcmp: Return negative if second string is larger", "[string/nstrc
|
|||
{
|
||||
error err;
|
||||
/* 'a' has a higher ASCII value than 'A' */
|
||||
string *s1 = nstr("aaaAa", nil);
|
||||
string *s2 = nstr("aaaaa", nil);
|
||||
nstr_t *s1 = nstr("aaaAa", nil);
|
||||
nstr_t *s2 = nstr("aaaaa", nil);
|
||||
|
||||
int diff = nstrcmp(s1, s2, &err);
|
||||
|
||||
|
|
@ -101,11 +101,11 @@ TEST_CASE( "nstrcmp: Return negative if second string is larger", "[string/nstrc
|
|||
TEST_CASE( "nstrcmp: Error if first string is nil", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s2 = nstr("aaaaa", nil);
|
||||
nstr_t *s2 = nstr("aaaaa", nil);
|
||||
usize diff = nstrcmp(nil, s2, &err);
|
||||
|
||||
string *expected_msg = nstr("First string is nil", nil);
|
||||
string *actual_msg = errmsg(&err);
|
||||
nstr_t *expected_msg = nstr("First string is nil", nil);
|
||||
nstr_t *actual_msg = errmsg(&err);
|
||||
|
||||
REQUIRE( diff > 0 );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
@ -119,11 +119,11 @@ TEST_CASE( "nstrcmp: Error if first string is nil", "[string/nstrcat.c]" )
|
|||
TEST_CASE( "nstrcmp: Error if second string is nil", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s1 = nstr("aaaaa", nil);
|
||||
nstr_t *s1 = nstr("aaaaa", nil);
|
||||
usize diff = nstrcmp(s1, nil, &err);
|
||||
|
||||
string *expected_msg = nstr("Second string is nil", nil);
|
||||
string *actual_msg = errmsg(&err);
|
||||
nstr_t *expected_msg = nstr("Second string is nil", nil);
|
||||
nstr_t *actual_msg = errmsg(&err);
|
||||
|
||||
REQUIRE( diff > 0 );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
|
|||
|
|
@ -8,8 +8,8 @@
|
|||
TEST_CASE( "nstrdup: Duplicate a string", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s = nstr("aaaaa", nil);
|
||||
string *dup = nstrdup(s, &err);
|
||||
nstr_t *s = nstr("aaaaa", nil);
|
||||
nstr_t *dup = nstrdup(s, &err);
|
||||
|
||||
REQUIRE( dup != nil );
|
||||
REQUIRE( dup != s );
|
||||
|
|
@ -23,9 +23,9 @@ TEST_CASE( "nstrdup: Duplicate a string", "[string/nstrcat.c]" )
|
|||
TEST_CASE( "nstrdup: Error if string is nil", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *dup = nstrdup(nil, &err);
|
||||
nstr_t *dup = nstrdup(nil, &err);
|
||||
|
||||
string *expected_msg = nstr("String is nil", nil);
|
||||
nstr_t *expected_msg = nstr("String is nil", nil);
|
||||
|
||||
REQUIRE( dup == nil );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
|
|||
|
|
@ -8,10 +8,10 @@
|
|||
TEST_CASE( "nstrmul: Repeat a string", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s = nstr("aaaaa", nil);
|
||||
nstr_t *s = nstr("aaaaa", nil);
|
||||
|
||||
string *expected = nstr("aaaaaaaaaaaaaaa", nil);
|
||||
string *actual = nstrmul(s, 3, &err);
|
||||
nstr_t *expected = nstr("aaaaaaaaaaaaaaa", nil);
|
||||
nstr_t *actual = nstrmul(s, 3, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nlen(actual) == 5 * 3 );
|
||||
|
|
@ -26,9 +26,9 @@ TEST_CASE( "nstrmul: Repeat a string", "[string/nstrcat.c]" )
|
|||
TEST_CASE( "nstrmul: Duplicate a string if count is 1", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s = nstr("aaaaa", nil);
|
||||
nstr_t *s = nstr("aaaaa", nil);
|
||||
|
||||
string *mul = nstrmul(s, 1, &err);
|
||||
nstr_t *mul = nstrmul(s, 1, &err);
|
||||
|
||||
REQUIRE( nul != nil );
|
||||
REQUIRE( nlen(mul) == 5 );
|
||||
|
|
@ -42,9 +42,9 @@ TEST_CASE( "nstrmul: Duplicate a string if count is 1", "[string/nstrcat.c]" )
|
|||
TEST_CASE( "nstrmul: Error if string is nil", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *mul = nstrmul(nil, 1, &err);
|
||||
nstr_t *mul = nstrmul(nil, 1, &err);
|
||||
|
||||
string *expected_msg = nstr("String is nil", nil);
|
||||
nstr_t *expected_msg = nstr("String is nil", nil);
|
||||
|
||||
REQUIRE( mul == nil );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
@ -56,10 +56,10 @@ TEST_CASE( "nstrmul: Error if string is nil", "[string/nstrcat.c]" )
|
|||
TEST_CASE( "nstrmul: Return empty string if count is 0", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s = nstr("aaaaa", nil);
|
||||
string *mul = nstrmul(s, 0, &err);
|
||||
nstr_t *s = nstr("aaaaa", nil);
|
||||
nstr_t *mul = nstrmul(s, 0, &err);
|
||||
|
||||
string *expected_msg = nstr("String is nil", nil);
|
||||
nstr_t *expected_msg = nstr("String is nil", nil);
|
||||
|
||||
REQUIRE( mul == nil );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
@ -71,9 +71,9 @@ TEST_CASE( "nstrmul: Return empty string if count is 0", "[string/nstrcat.c]" )
|
|||
TEST_CASE( "nstrmul: Error if string is nil", "[string/nstrcat.c]" )
|
||||
{
|
||||
error err;
|
||||
string *mul = nstrmul(nil, 3, &err);
|
||||
nstr_t *mul = nstrmul(nil, 3, &err);
|
||||
|
||||
string *expected_msg = nstr("String is nil", nil);
|
||||
nstr_t *expected_msg = nstr("String is nil", nil);
|
||||
|
||||
REQUIRE( mul == nil );
|
||||
REQUIRE( errnum(&err) == EFAULT );
|
||||
|
|
|
|||
|
|
@ -9,8 +9,8 @@ TEST_CASE( "u2nstr: Convert 0 to base 2", "[string/x2nstr.c]" )
|
|||
{
|
||||
error err;
|
||||
|
||||
string *expected = nstr("0", nil);
|
||||
string *actual = u2nstr(0, 2, &err);
|
||||
nstr_t *expected = nstr("0", nil);
|
||||
nstr_t *actual = u2nstr(0, 2, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -24,8 +24,8 @@ TEST_CASE( "u2nstr: Convert 0 to base 36", "[string/x2nstr.c]" )
|
|||
{
|
||||
error err;
|
||||
|
||||
string *expected = nstr("0", nil);
|
||||
string *actual = u2nstr(0, 36, &err);
|
||||
nstr_t *expected = nstr("0", nil);
|
||||
nstr_t *actual = u2nstr(0, 36, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -39,8 +39,8 @@ TEST_CASE( "u2nstr: Convert 255 to base 2", "[string/x2nstr.c]" )
|
|||
{
|
||||
error err;
|
||||
|
||||
string *expected = nstr("11111111", nil);
|
||||
string *actual = u2nstr(255, 2, &err);
|
||||
nstr_t *expected = nstr("11111111", nil);
|
||||
nstr_t *actual = u2nstr(255, 2, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -54,8 +54,8 @@ TEST_CASE( "u2nstr: Convert 1679615 to base 36", "[string/x2nstr.c]" )
|
|||
{
|
||||
error err;
|
||||
|
||||
string *expected = nstr("zzzz", nil);
|
||||
string *actual = u2nstr(1679615, 36, &err);
|
||||
nstr_t *expected = nstr("zzzz", nil);
|
||||
nstr_t *actual = u2nstr(1679615, 36, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -69,8 +69,8 @@ TEST_CASE( "u2nstr: Convert 2^64-1 to base 16", "[string/x2nstr.c]" )
|
|||
{
|
||||
error err;
|
||||
|
||||
string *expected = nstr("ffffffffffffffff", nil);
|
||||
string *actual = u2nstr(0xffffffffffffffff, 16, &err);
|
||||
nstr_t *expected = nstr("ffffffffffffffff", nil);
|
||||
nstr_t *actual = u2nstr(0xffffffffffffffff, 16, &err);
|
||||
|
||||
REQUIRE( actual != nil );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -83,10 +83,10 @@ TEST_CASE( "u2nstr: Convert 2^64-1 to base 16", "[string/x2nstr.c]" )
|
|||
TEST_CASE( "u2nstr: Error if base too low", "[string/x2nstr.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s = u2nstr(420, 1, &err);
|
||||
nstr_t *s = u2nstr(420, 1, &err);
|
||||
|
||||
string *expected_msg = nstr("Numerical base out of range", nil);
|
||||
string *actual_msg = errmsg(&err);
|
||||
nstr_t *expected_msg = nstr("Numerical base out of range", nil);
|
||||
nstr_t *actual_msg = errmsg(&err);
|
||||
|
||||
REQUIRE( s == nil );
|
||||
REQUIRE( nstreq(expected_msg, actual_msg, nil) );
|
||||
|
|
@ -99,10 +99,10 @@ TEST_CASE( "u2nstr: Error if base too low", "[string/x2nstr.c]" )
|
|||
TEST_CASE( "u2nstr: Error if base too high", "[string/x2nstr.c]" )
|
||||
{
|
||||
error err;
|
||||
string *s = u2nstr(420, 37, &err);
|
||||
nstr_t *s = u2nstr(420, 37, &err);
|
||||
|
||||
string *expected_msg = nstr("Numerical base out of range", nil);
|
||||
string *actual_msg = errmsg(&err);
|
||||
nstr_t *expected_msg = nstr("Numerical base out of range", nil);
|
||||
nstr_t *actual_msg = errmsg(&err);
|
||||
|
||||
REQUIRE( s == nil );
|
||||
REQUIRE( nstreq(expected_msg, actual_msg, nil) );
|
||||
|
|
|
|||
|
|
@ -50,8 +50,8 @@ TEST_CASE( "utf8_check: Error on malformed sequence start", "[string/utf.c]" )
|
|||
error err;
|
||||
utf8_check("\xff", &err);
|
||||
|
||||
string *expected = nstr("Illegal UTF-8 sequence start byte: 0xff", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Illegal UTF-8 sequence start byte: 0xff", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -63,8 +63,8 @@ TEST_CASE( "utf8_check: Error on wrong second byte", "[string/utf.c]" )
|
|||
error err;
|
||||
utf8_check("\xce\xff", &err);
|
||||
|
||||
string *expected = nstr("Byte 2 in UTF-8 sequence invalid: 0xff", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Byte 2 in UTF-8 sequence invalid: 0xff", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -76,8 +76,8 @@ TEST_CASE( "utf8_check: Error on wrong third byte", "[string/utf.c]" )
|
|||
error err;
|
||||
utf8_check("\xe3\x81\xff", &err);
|
||||
|
||||
string *expected = nstr("Byte 3 in UTF-8 sequence invalid: 0xff", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Byte 3 in UTF-8 sequence invalid: 0xff", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -89,8 +89,8 @@ TEST_CASE( "utf8_check: Error on wrong fourth byte", "[string/utf.c]" )
|
|||
error err;
|
||||
utf8_check("\xf0\x9f\xa5\xff", &err);
|
||||
|
||||
string *expected = nstr("Byte 4 in UTF-8 sequence invalid: 0xff", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Byte 4 in UTF-8 sequence invalid: 0xff", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -102,8 +102,8 @@ TEST_CASE( "utf8_check: Error on non canonical encoding", "[string/utf.c]" )
|
|||
error err;
|
||||
utf8_check("\xf0\x80\x80\xa0", &err);
|
||||
|
||||
string *expected = nstr("Non canonical UTF-8 encoding: 1 byte character stored in 4 bytes", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Non canonical UTF-8 encoding: 1 byte character stored in 4 bytes", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
|
|||
|
|
@ -51,8 +51,8 @@ TEST_CASE( "utf8_chrsize: Error if out of Unicode range", "[string/utf.c]" )
|
|||
/* Unicode range is 0x00~0x10ffff */
|
||||
usize size = utf8_chrsize(0x110000, &err);
|
||||
|
||||
string *expected = nstr("Character code not within Unicode range", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Character code not within Unicode range", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( size == 0 );
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
|
|
|
|||
|
|
@ -76,8 +76,8 @@ TEST_CASE( "utf8_from_nchr: Error if out of Unicode range", "[string/utf.c]" )
|
|||
/* Unicode range is 0x00~0x10ffff */
|
||||
usize size = utf8_from_nchr(&buf[0], 0x110000, &err);
|
||||
|
||||
string *expected = nstr("Character code not within Unicode range", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Character code not within Unicode range", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( buf[0] == '\0' );
|
||||
REQUIRE( buf[1] == '\xff' );
|
||||
|
|
|
|||
|
|
@ -64,8 +64,8 @@ TEST_CASE( "utf8_ncheck: Error on malformed sequence start", "[string/utf.c]" )
|
|||
error err;
|
||||
utf8_ncheck("\xff", 1, &err);
|
||||
|
||||
string *expected = nstr("Illegal UTF-8 sequence start byte: 0xff", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Illegal UTF-8 sequence start byte: 0xff", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -77,8 +77,8 @@ TEST_CASE( "utf8_ncheck: Error on wrong second byte", "[string/utf.c]" )
|
|||
error err;
|
||||
utf8_ncheck("\xce\xff", 2, &err);
|
||||
|
||||
string *expected = nstr("Byte 2 in UTF-8 sequence invalid: 0xff", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Byte 2 in UTF-8 sequence invalid: 0xff", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -90,8 +90,8 @@ TEST_CASE( "utf8_ncheck: Error on wrong third byte", "[string/utf.c]" )
|
|||
error err;
|
||||
utf8_ncheck("\xe3\x81\xff", 3, &err);
|
||||
|
||||
string *expected = nstr("Byte 3 in UTF-8 sequence invalid: 0xff", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Byte 3 in UTF-8 sequence invalid: 0xff", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -103,8 +103,8 @@ TEST_CASE( "utf8_ncheck: Error on wrong fourth byte", "[string/utf.c]" )
|
|||
error err;
|
||||
utf8_ncheck("\xf0\x9f\xa5\xff", 4, &err);
|
||||
|
||||
string *expected = nstr("Byte 4 in UTF-8 sequence invalid: 0xff", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Byte 4 in UTF-8 sequence invalid: 0xff", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
@ -116,8 +116,8 @@ TEST_CASE( "utf8_ncheck: Error on non canonical encoding", "[string/utf.c]" )
|
|||
error err;
|
||||
utf8_ncheck("\xf0\x80\x80\xa0", 4, &err);
|
||||
|
||||
string *expected = nstr("Non canonical UTF-8 encoding: 1 byte character stored in 4 bytes", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Non canonical UTF-8 encoding: 1 byte character stored in 4 bytes", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
REQUIRE( nstreq(expected, actual, nil) );
|
||||
|
|
|
|||
|
|
@ -63,8 +63,8 @@ TEST_CASE( "utf8_to_nchr: Error on malformed sequence start", "[string/utf.c]" )
|
|||
nchar c;
|
||||
utf8_to_nchr(&c, "\xff", &err);
|
||||
|
||||
string *expected = nstr("Illegal UTF-8 sequence start byte: 0xff", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Illegal UTF-8 sequence start byte: 0xff", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( c == '\0' );
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
|
|
@ -78,8 +78,8 @@ TEST_CASE( "utf8_to_nchr: Error on wrong second byte", "[string/utf.c]" )
|
|||
nchar c;
|
||||
utf8_to_nchr(&c, "\xce\xff", &err);
|
||||
|
||||
string *expected = nstr("Byte 2 in UTF-8 sequence invalid: 0xff", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Byte 2 in UTF-8 sequence invalid: 0xff", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( c == '\0' );
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
|
|
@ -93,8 +93,8 @@ TEST_CASE( "utf8_to_nchr: Error on wrong third byte", "[string/utf.c]" )
|
|||
nchar c;
|
||||
utf8_to_nchr(&c, "\xe3\x81\xff", &err);
|
||||
|
||||
string *expected = nstr("Byte 3 in UTF-8 sequence invalid: 0xff", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Byte 3 in UTF-8 sequence invalid: 0xff", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( c == '\0' );
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
|
|
@ -108,8 +108,8 @@ TEST_CASE( "utf8_to_nchr: Error on wrong fourth byte", "[string/utf.c]" )
|
|||
nchar c;
|
||||
utf8_to_nchr(&c, "\xf0\x9f\xa5\xff", &err);
|
||||
|
||||
string *expected = nstr("Byte 4 in UTF-8 sequence invalid: 0xff", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Byte 4 in UTF-8 sequence invalid: 0xff", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( c == '\0' );
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
|
|
@ -123,8 +123,8 @@ TEST_CASE( "utf8_to_nchr: Error on non canonical encoding", "[string/utf.c]" )
|
|||
nchar c;
|
||||
utf8_to_nchr(&c, "\xf0\x80\x80\xa0", &err);
|
||||
|
||||
string *expected = nstr("Non canonical UTF-8 encoding: 1 byte character stored in 4 bytes", nil);
|
||||
string *actual = errmsg(&err);
|
||||
nstr_t *expected = nstr("Non canonical UTF-8 encoding: 1 byte character stored in 4 bytes", nil);
|
||||
nstr_t *actual = errmsg(&err);
|
||||
|
||||
REQUIRE( c == '\0' );
|
||||
REQUIRE( errnum(&err) == EINVAL );
|
||||
|
|
|
|||
Loading…
Reference in a new issue