// test_strtou.c
// String conversion unit test for libutil
// Copyright (C) 2021, Jakob Wakeling
// MIT Licence

#include "../strconv.h"
#include "unit.h"

#include <stdint.h>
#include <stdio.h>
#include <errno.h>

int main(void) {
	/* STRTOU8 */
	{
		char i[] = "0";
		
		ASSERT("T000 STRTOU8 ZERO BASE 0",
				strtou8(i, NULL, 0) == 0);
		
		ASSERT("T001 STRTOU8 ZERO BASE 8",
				strtou8(i, NULL, 8) == 0);
	}
	
	{
		char i[] = "64";
		
		ASSERT("T002 STRTOU8 NORMAL BASE 0",
				strtou8(i, NULL, 0) == 64);
		
		ASSERT("T003 STRTOU8 NORMAL BASE 8",
				strtou8(i, NULL, 8) == 52);
		
		ASSERT("T004 STRTOU8 NORMAL BASE 10",
				strtou8(i, NULL, 10) == 64);
		
		ASSERT("T005 STRTOU8 NORMAL BASE 16",
				strtou8(i, NULL, 16) == 100);
	}
	
	{
		char i[] = "3M";
		
		ASSERT("T006 STRTOU8 NORMAL BASE 36",
				strtou8(i, NULL, 36) == 130u);
	}
	
	{
		char i8[] = "0377";
		char i10[] = "255";
		char i16[] = "0xFF";
		
		errno = 0;
		ASSERT("T007 STRTOU8 MAX BASE 0",
				strtou8(i8, NULL, 0) == UINT8_MAX && errno != ERANGE);
		
		errno = 0;
		ASSERT("T008 STRTOU8 MAX BASE 8",
				strtou8(i8, NULL, 8) == UINT8_MAX && errno != ERANGE);
		
		errno = 0;
		ASSERT("T009 STRTOU8 MAX BASE 10",
				strtou8(i10, NULL, 10) == UINT8_MAX && errno != ERANGE);
		
		errno = 0;
		ASSERT("T010 STRTOU8 MAX BASE 16",
				strtou8(i16, NULL, 16) == UINT8_MAX && errno != ERANGE);
	}
	
	{
		char i[] = "-153";
		
		errno = 0;
		ASSERT("T011 STRTOU8 NEGATIVE",
				!strtou8(i, NULL, 10) && errno == EINVAL);
		
		errno = 0;
		ASSERT("T012 STRTOU8 BASE 1",
				!strtou8(i, NULL, 1) && errno == EINVAL);
		
		errno = 0;
		ASSERT("T013 STRTOU8 BASE -1",
				!strtou8(i, NULL, -1) && errno == EINVAL);
		
		errno = 0;
		ASSERT("T014 STRTOU8 BASE 37",
				!strtou8(i, NULL, 37) && errno == EINVAL);
	}
	
	{
		char i[] = "257";
		
		errno = 0;
		ASSERT("T015 STRTOU8 OVERFLOW",
				strtou8(i, NULL, 10) == UINT8_MAX && errno == ERANGE);
	}
	
	/* STRTOU16 */
	{
		char i[] = "0";
		
		ASSERT("T100 STRTOU16 ZERO BASE 0",
				strtou16(i, NULL, 0) == 0);
		
		ASSERT("T101 STRTOU16 ZERO BASE 8",
				strtou16(i, NULL, 8) == 0);
	}
	
	{
		char i[] = "64";
		
		ASSERT("T102 STRTOU16 NORMAL BASE 0",
				strtou16(i, NULL, 0) == 64);
		
		ASSERT("T103 STRTOU16 NORMAL BASE 8",
				strtou16(i, NULL, 8) == 52);
		
		ASSERT("T104 STRTOU16 NORMAL BASE 10",
				strtou16(i, NULL, 10) == 64);
		
		ASSERT("T105 STRTOU16 NORMAL BASE 16",
				strtou16(i, NULL, 16) == 100);
	}
	
	{
		char i[] = "AZ1";
		
		ASSERT("T106 STRTOU16 NORMAL BASE 36",
				strtou16(i, NULL, 36) == 14221u);
	}
	
	{
		char i8[] = "0177777";
		char i10[] = "65535";
		char i16[] = "0xFFFF";
		
		errno = 0;
		ASSERT("T107 STRTOU16 MAX BASE 0",
				strtou16(i8, NULL, 0) == UINT16_MAX && errno != ERANGE);
		
		errno = 0;
		ASSERT("T108 STRTOU16 MAX BASE 8",
				strtou16(i8, NULL, 8) == UINT16_MAX && errno != ERANGE);
		
		errno = 0;
		ASSERT("T109 STRTOU16 MAX BASE 10",
				strtou16(i10, NULL, 10) == UINT16_MAX && errno != ERANGE);
		
		errno = 0;
		ASSERT("T110 STRTOU16 MAX BASE 16",
				strtou16(i16, NULL, 16) == UINT16_MAX && errno != ERANGE);
	}
	
	{
		char i[] = "-153";
		
		errno = 0;
		ASSERT("T111 STRTOU16 NEGATIVE",
				!strtou16(i, NULL, 10) && errno == EINVAL);
		
		errno = 0;
		ASSERT("T112 STRTOU16 BASE 1",
				!strtou16(i, NULL, 1) && errno == EINVAL);
		
		errno = 0;
		ASSERT("T113 STRTOU16 BASE -1",
				!strtou16(i, NULL, -1) && errno == EINVAL);
		
		errno = 0;
		ASSERT("T114 STRTOU16 BASE 37",
				!strtou16(i, NULL, 37) && errno == EINVAL);
	}
	
	{
		char i[] = "65537";
		
		errno = 0;
		ASSERT("T115 STRTOU16 OVERFLOW",
				strtou16(i, NULL, 10) == UINT16_MAX && errno == ERANGE);
	}
	
	/* STRTOU32 */
	{
		char i[] = "0";
		
		ASSERT("T200 STRTOU32 ZERO BASE 0",
				strtou32(i, NULL, 0) == 0);
		
		ASSERT("T201 STRTOU32 ZERO BASE 8",
				strtou32(i, NULL, 8) == 0);
	}
	
	{
		char i[] = "64";
		
		ASSERT("T202 STRTOU32 NORMAL BASE 0",
				strtou32(i, NULL, 0) == 64);
		
		ASSERT("T203 STRTOU32 NORMAL BASE 8",
				strtou32(i, NULL, 8) == 52);
		
		ASSERT("T204 STRTOU32 NORMAL BASE 10",
				strtou32(i, NULL, 10) == 64);
		
		ASSERT("T205 STRTOU32 NORMAL BASE 16",
				strtou32(i, NULL, 16) == 100);
	}
	
	{
		char i[] = "T7A7J";
		
		ASSERT("T206 STRTOU32 NORMAL BASE 36",
				strtou32(i, NULL, 36) == 49048687u);
	}
	
	{
		char i8[] = "037777777777";
		char i10[] = "4294967295";
		char i16[] = "0xFFFFFFFF";
		
		errno = 0;
		ASSERT("T207 STRTOU32 MAX BASE 0",
				strtou32(i8, NULL, 0) == UINT32_MAX && errno != ERANGE);
		
		errno = 0;
		ASSERT("T208 STRTOU32 MAX BASE 8",
				strtou32(i8, NULL, 8) == UINT32_MAX && errno != ERANGE);
		
		errno = 0;
		ASSERT("T209 STRTOU32 MAX BASE 10",
				strtou32(i10, NULL, 10) == UINT32_MAX && errno != ERANGE);
		
		errno = 0;
		ASSERT("T210 STRTOU32 MAX BASE 16",
				strtou32(i16, NULL, 16) == UINT32_MAX && errno != ERANGE);
	}
	
	{
		char i[] = "-153";
		
		errno = 0;
		ASSERT("T211 STRTOU32 NEGATIVE",
				!strtou32(i, NULL, 10) && errno == EINVAL);
		
		errno = 0;
		ASSERT("T212 STRTOU32 BASE 1",
				!strtou32(i, NULL, 1) && errno == EINVAL);
		
		errno = 0;
		ASSERT("T213 STRTOU32 BASE -1",
				!strtou32(i, NULL, -1) && errno == EINVAL);
		
		errno = 0;
		ASSERT("T214 STRTOU32 BASE 37",
				!strtou32(i, NULL, 37) && errno == EINVAL);
	}
	
	{
		char i[] = "4294967297";
		
		errno = 0;
		ASSERT("T215 STRTOU32 OVERFLOW",
				strtou32(i, NULL, 10) == UINT32_MAX && errno == ERANGE);
	}
	
	/* STRTOU64 */
	{
		char i[] = "0";
		
		ASSERT("T300 STRTOU64 ZERO BASE 0",
				strtou64(i, NULL, 0) == 0);
		
		ASSERT("T301 STRTOU64 ZERO BASE 8",
				strtou64(i, NULL, 8) == 0);
	}
	
	{
		char i[] = "64";
		
		ASSERT("T302 STRTOU64 NORMAL BASE 0",
				strtou64(i, NULL, 0) == 64);
		
		ASSERT("T303 STRTOU64 NORMAL BASE 8",
				strtou64(i, NULL, 8) == 52);
		
		ASSERT("T304 STRTOU64 NORMAL BASE 10",
				strtou64(i, NULL, 10) == 64);
		
		ASSERT("T305 STRTOU64 NORMAL BASE 16",
				strtou64(i, NULL, 16) == 100);
	}
	
	{
		char i[] = "3579ADGJMPSVZ";
		
		ASSERT("T306 STRTOU64 NORMAL BASE 36",
				strtou64(i, NULL, 36) == 14899788948715380863u);
	}
	
	{
		char i8[] = "01777777777777777777777";
		char i10[] = "18446744073709551615";
		char i16[] = "0xFFFFFFFFFFFFFFFF";
		
		errno = 0;
		ASSERT("T307 STRTOU64 MAX BASE 0",
				strtou64(i8, NULL, 0) == UINT64_MAX && errno != ERANGE);
		
		errno = 0;
		ASSERT("T308 STRTOU64 MAX BASE 8",
				strtou64(i8, NULL, 8) == UINT64_MAX && errno != ERANGE);
		
		errno = 0;
		ASSERT("T309 STRTOU64 MAX BASE 10",
				strtou64(i10, NULL, 10) == UINT64_MAX && errno != ERANGE);
		
		errno = 0;
		ASSERT("T310 STRTOU64 MAX BASE 16",
				strtou64(i16, NULL, 16) == UINT64_MAX && errno != ERANGE);
	}
	
	{
		char i[] = "-153";
		
		errno = 0;
		ASSERT("T311 STRTOU64 NEGATIVE",
				!strtou64(i, NULL, 10) && errno == EINVAL);
		
		errno = 0;
		ASSERT("T312 STRTOU64 BASE 1",
				!strtou64(i, NULL, 1) && errno == EINVAL);
		
		errno = 0;
		ASSERT("T313 STRTOU64 BASE -1",
				!strtou64(i, NULL, -1) && errno == EINVAL);
		
		errno = 0;
		ASSERT("T314 STRTOU64 BASE 37",
				!strtou64(i, NULL, 37) && errno == EINVAL);
	}
	
	{
		char i[] = "18446744073709551616";
		
		errno = 0;
		ASSERT("T315 STRTOU64 OVERFLOW",
				strtou64(i, NULL, 10) == UINT64_MAX && errno == ERANGE);
	}
	
	printf("%d of %d tests passed\n", testspassed, testsrun);
	return testsfailed;
}