int main(void)
{
int ret = -1;
CREATE_TEST(pwm, 15)
ADD_TEST_CASE(pwm, get_set_duty_cycle_before_init);
ADD_TEST_CASE(pwm, get_set_period_before_init);
ADD_TEST_CASE(pwm, get_set_frequency_before_init);
ADD_TEST_CASE(pwm, init_invalid_index);
ADD_TEST_CASE(pwm, release_invalid_index);
ADD_TEST_CASE(pwm, init);
ADD_TEST_CASE(pwm, get_duty_cycle_null_var);
ADD_TEST_CASE(pwm, get_period_null_var);
ADD_TEST_CASE(pwm, get_frequency_null_var);
ADD_TEST_CASE(pwm, get_set_duty_cycle_invalid_index);
ADD_TEST_CASE(pwm, get_set_period_invalid_index);
ADD_TEST_CASE(pwm, get_set_frequency_invalid_index);
ADD_TEST_CASE(pwm, set_frequency);
ADD_TEST_CASE(pwm, release);
ADD_TEST_CASE(pwm, manual_check);
ret = run_test(test_pwm);
free(test_pwm.cases);
return ret;
}
int main(int argc, char* argv[]){
CREATE_TEST(Test_Smear);
RUN_TEST;
CLEAR_TEST;
return 0;
}
FATAL_TEST(enums, try_parse) {
# define CREATE_TEST(e, x) \
do { \
std::string const s(FATAL_TO_STR(x)); \
e out = static_cast<e>(-1); \
FATAL_EXPECT_TRUE(enum_traits<e>::try_parse(out, s)); \
FATAL_EXPECT_EQ(e::x, out); \
\
out = static_cast<e>(-1); \
FATAL_EXPECT_TRUE(enum_traits<e>::try_parse(out, s.begin(), s.end())); \
FATAL_EXPECT_EQ(e::x, out); \
\
out = static_cast<e>(-1); \
FATAL_EXPECT_FALSE(enum_traits<e>::try_parse(out, s.begin(), s.begin())); \
FATAL_EXPECT_EQ(static_cast<e>(-1), out); \
\
FATAL_EXPECT_FALSE( \
enum_traits<e>::try_parse( \
out, s.begin(), std::next(s.begin(), s.size() - 1) \
) \
); \
FATAL_EXPECT_EQ(static_cast<e>(-1), out); \
\
auto const i = s + "invalid"; \
FATAL_EXPECT_FALSE((enum_traits<e>::try_parse(out, i))); \
FATAL_EXPECT_FALSE((enum_traits<e>::try_parse(out, i.begin(), i.end()))); \
} while (false)
CREATE_TEST(test_enum, state0);
CREATE_TEST(test_enum, state1);
CREATE_TEST(test_enum, state2);
CREATE_TEST(test_enum, state3);
CREATE_TEST(custom_enum, field0);
CREATE_TEST(custom_enum, field1);
CREATE_TEST(custom_enum, field2);
# undef CREATE_TEST
{
using traits = enum_traits<test_enum>;
traits::type out;
FATAL_EXPECT_FALSE(traits::try_parse(out, std::string()));
FATAL_EXPECT_FALSE(traits::try_parse(out, std::string("invalid")));
}
{
using traits = enum_traits<custom_enum>;
traits::type out;
FATAL_EXPECT_FALSE(traits::try_parse(out, std::string()));
FATAL_EXPECT_FALSE(traits::try_parse(out, std::string("invalid")));
}
}
int main(int argc, char **argv) {
SceLwMutexWorkarea workarea, workarea1, workarea2;
int result1, result2;
// Crash.
//CREATE_TEST("NULL workarea", NULL, "test", 0, 0, NULL);
CREATE_TEST("NULL name", &workarea, NULL, 0, 0, NULL);
CREATE_TEST("Blank name", &workarea, "", 0, 0, NULL);
CREATE_TEST("Long name", &workarea, "1234567890123456789012345678901234567890123456789012345678901234", 0, 0, NULL);
CREATE_TEST("Weird attr", &workarea, "create", 1, 0, NULL);
CREATE_TEST("0x100 attr", &workarea, "create", 0x100, 0, NULL);
CREATE_TEST("0x200 attr", &workarea, "create", 0x200, 0, NULL);
CREATE_TEST("0x300 attr", &workarea, "create", 0x300, 0, NULL);
CREATE_TEST("0x3FF attr", &workarea, "create", 0x3FF, 0, NULL);
CREATE_TEST("0x400 attr", &workarea, "create", 0x400, 0, NULL);
CREATE_TEST("Positive count", &workarea, "create", 0, 1, NULL);
CREATE_TEST("Negative count", &workarea, "create", 0, -1, NULL);
CREATE_TEST("Count = -5", &workarea, "create", 0, -5, NULL);
CREATE_TEST("Count = 2", &workarea, "create", 0, 2, NULL);
CREATE_TEST("Negative count (recursive)", &workarea, "create", 0x200, -1, NULL);
CREATE_TEST("Count = -5 (recursive)", &workarea, "create", 0x200, -5, NULL);
CREATE_TEST("Count = 2 (recursive)", &workarea, "create", 0x200, 2, NULL);
CREATE_TEST("Medium count (recursive)", &workarea, "create", 0x200, 255, NULL);
CREATE_TEST("Large count (recursive)", &workarea, "create", 0x200, 65537, NULL);
result1 = sceKernelCreateLwMutex(&workarea1, "create", 0, 0, NULL);
result2 = sceKernelCreateLwMutex(&workarea2, "create", 0, 0, NULL);
if (result1 == 0 && result2 == 0) {
printf("Two with same name: OK\n");
} else {
printf("Two with same name: Failed (%X, %X)\n", result1, result2);
}
sceKernelDeleteLwMutex(&workarea1);
sceKernelDeleteLwMutex(&workarea2);
sceKernelCreateLwMutex(&workarea, "create1", 0, 0, NULL);
CREATE_TEST("Two with same workarea", &workarea, "create2", 0, 0, NULL);
// Leaks.
BASIC_SCHED_TEST("NULL name",
result = sceKernelCreateLwMutex(&workarea, NULL, 0, 0, NULL);
);
FATAL_TEST(enums, parse) {
# define CREATE_TEST(e, x) \
do { \
std::string const s(FATAL_TO_STR(x)); \
FATAL_EXPECT_EQ(e::x, enum_traits<e>::parse(s)); \
FATAL_EXPECT_EQ(e::x, enum_traits<e>::parse(s.begin(), s.end())); \
FATAL_EXPECT_THROW(std::invalid_argument) { \
enum_traits<e>::parse(s.begin(), s.begin()); \
}; \
} while (false)
CREATE_TEST(test_enum, state0);
CREATE_TEST(test_enum, state1);
CREATE_TEST(test_enum, state2);
CREATE_TEST(test_enum, state3);
CREATE_TEST(custom_enum, field0);
CREATE_TEST(custom_enum, field1);
CREATE_TEST(custom_enum, field2);
# undef CREATE_TEST
# define CREATE_TEST(e, x) \
do { \
std::string const s(FATAL_TO_STR(x)); \
FATAL_EXPECT_THROW(std::invalid_argument) { \
enum_traits<e>::parse(s.begin(), std::next(s.begin(), s.size() - 1)); \
}; \
} while (false)
CREATE_TEST(test_enum, state0);
CREATE_TEST(test_enum, state1);
CREATE_TEST(test_enum, state2);
CREATE_TEST(test_enum, state3);
CREATE_TEST(custom_enum, field0);
CREATE_TEST(custom_enum, field1);
CREATE_TEST(custom_enum, field2);
# undef CREATE_TEST
# define CREATE_TEST(e, x) \
do { \
std::string const s(FATAL_TO_STR(x) "invalid"); \
FATAL_EXPECT_THROW(std::invalid_argument) { \
enum_traits<e>::parse(s); \
}; \
} while (false)
CREATE_TEST(test_enum, state0);
CREATE_TEST(test_enum, state1);
CREATE_TEST(test_enum, state2);
CREATE_TEST(test_enum, state3);
CREATE_TEST(custom_enum, field0);
CREATE_TEST(custom_enum, field1);
CREATE_TEST(custom_enum, field2);
# undef CREATE_TEST
# define CREATE_TEST(e, x) \
do { \
std::string const s(FATAL_TO_STR(x) "invalid"); \
FATAL_EXPECT_THROW(std::invalid_argument) { \
enum_traits<e>::parse(s.begin(), s.end()); \
}; \
} while (false)
CREATE_TEST(test_enum, state0);
CREATE_TEST(test_enum, state1);
CREATE_TEST(test_enum, state2);
CREATE_TEST(test_enum, state3);
CREATE_TEST(custom_enum, field0);
CREATE_TEST(custom_enum, field1);
CREATE_TEST(custom_enum, field2);
# undef CREATE_TEST
{
using traits = enum_traits<test_enum>;
FATAL_EXPECT_THROW(std::invalid_argument) {
traits::parse(std::string());
};
FATAL_EXPECT_THROW(std::invalid_argument) {
traits::parse(std::string("invalid"));
};
}
{
using traits = enum_traits<custom_enum>;
FATAL_EXPECT_THROW(std::invalid_argument) {
traits::parse(std::string());
};
FATAL_EXPECT_THROW(std::invalid_argument) {
traits::parse(std::string("invalid"));
};
}
}
