summaryrefslogtreecommitdiffstatshomepage
path: root/src/emu/validity.cpp
diff options
context:
space:
mode:
author Vas Crabb <vas@vastheman.com>2016-07-15 16:18:42 +1000
committer Vas Crabb <vas@vastheman.com>2016-07-15 16:18:42 +1000
commit7d5da01f947546f9538f2244ceb02a807e7cb5bc (patch)
treea0b3608afab05e7ab046544f7a135bd126a82271 /src/emu/validity.cpp
parent231bfb62379c1b1c21ed8d556e465a96abc5c506 (diff)
check a bunch more RGB operations in validity (nw)
implement the missing ones in rgbgen format similar one-liners in a more tabular way use default copy construct/assign
Diffstat (limited to 'src/emu/validity.cpp')
-rw-r--r--src/emu/validity.cpp349
1 files changed, 319 insertions, 30 deletions
diff --git a/src/emu/validity.cpp b/src/emu/validity.cpp
index d9e26597f27..b6a90b396fb 100644
--- a/src/emu/validity.cpp
+++ b/src/emu/validity.cpp
@@ -380,7 +380,7 @@ void validity_checker::validate_core()
void validity_checker::validate_inlines()
{
- volatile UINT64 testu64a = random_i64();
+ volatile UINT64 testu64a = random_u64();
volatile INT64 testi64a = random_i64();
volatile UINT32 testu32a = random_u32();
volatile UINT32 testu32b = random_u32();
@@ -507,37 +507,41 @@ void validity_checker::validate_rgb()
{
/*
This performs cursory tests of most of the vector-optimised RGB
- utilities, concentrating on the low-level maths. It uses random
- values most of the time for a quick go/no-go indication rather
- than trying to exercise edge cases. It doesn't matter too much
- if the compiler optimises out some of the operations since it's
- really intended to check for logic bugs in the vector code.
-
- The following functions are not tested yet:
- rgbaint_t()
- clamp_and_clear(const UINT32)
- sign_extend(const UINT32, const UINT32)
- min(const INT32)
- max(const INT32)
- blend(const rgbaint_t&, UINT8)
- scale_and_clamp(const rgbaint_t&)
- scale_imm_and_clamp(const INT32)
- scale2_add_and_clamp(const rgbaint_t&, const rgbaint_t&, const rgbaint_t&)
- scale_add_and_clamp(const rgbaint_t&, const rgbaint_t&);
- scale_imm_add_and_clamp(const INT32, const rgbaint_t&);
- cmpeq(const rgbaint_t&)
- cmpeq_imm(const INT32)
- cmpeq_imm_rgba(const INT32, const INT32, const INT32, const INT32)
- cmpgt(const rgbaint_t&)
- cmpgt_imm(const INT32)
- cmpgt_imm_rgba(const INT32, const INT32, const INT32, const INT32)
- cmplt(const rgbaint_t&)
- cmplt_imm(const INT32)
- cmplt_imm_rgba(const INT32, const INT32, const INT32, const INT32)
- static bilinear_filter(UINT32, UINT32, UINT32, UINT32, UINT8, UINT8)
- bilinear_filter_rgbaint(UINT32, UINT32, UINT32, UINT32, UINT8, UINT8)
+ utilities, concentrating on the low-level maths. It uses random
+ values most of the time for a quick go/no-go indication rather
+ than trying to exercise edge cases. It doesn't matter too much
+ if the compiler optimises out some of the operations since it's
+ really intended to check for logic bugs in the vector code. If
+ the compiler can work out that the code produces the expected
+ result, that's good enough.
+
+ The tests for bitwise logical operations are ordered to minimise
+ the chance of all-zero or all-one patterns producing a
+ misleading good result.
+
+ The following functions are not tested yet:
+ rgbaint_t()
+ clamp_and_clear(const UINT32)
+ sign_extend(const UINT32, const UINT32)
+ min(const INT32)
+ max(const INT32)
+ blend(const rgbaint_t&, UINT8)
+ scale_and_clamp(const rgbaint_t&)
+ scale_imm_and_clamp(const INT32)
+ scale2_add_and_clamp(const rgbaint_t&, const rgbaint_t&, const rgbaint_t&)
+ scale_add_and_clamp(const rgbaint_t&, const rgbaint_t&);
+ scale_imm_add_and_clamp(const INT32, const rgbaint_t&);
+ static bilinear_filter(UINT32, UINT32, UINT32, UINT32, UINT8, UINT8)
+ bilinear_filter_rgbaint(UINT32, UINT32, UINT32, UINT32, UINT8, UINT8)
*/
+ auto random_i32_nolimit = [this]
+ {
+ INT32 result;
+ do { result = random_i32(); } while ((result == std::numeric_limits<INT32>::min()) || (result == std::numeric_limits<INT32>::max()));
+ return result;
+ };
+
volatile INT32 expected_a, expected_r, expected_g, expected_b;
volatile INT32 actual_a, actual_r, actual_g, actual_b;
volatile INT32 imm;
@@ -1034,6 +1038,291 @@ void validity_checker::validate_rgb()
rgb.set(actual_a, actual_r, actual_g, actual_b);
rgb >>= 11;
check_expected("rgbaint_t::operator>>=");
+
+ // test RGB equality comparison
+ actual_a = random_i32_nolimit();
+ actual_r = random_i32_nolimit();
+ actual_g = random_i32_nolimit();
+ actual_b = random_i32_nolimit();
+ expected_a = ~INT32(0);
+ expected_r = 0;
+ expected_g = 0;
+ expected_b = 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpeq(rgbaint_t(actual_a, actual_r - 1, actual_g + 1, std::numeric_limits<INT32>::min()));
+ check_expected("rgbaint_t::cmpeq");
+ expected_a = 0;
+ expected_r = ~INT32(0);
+ expected_g = 0;
+ expected_b = 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpeq(rgbaint_t(std::numeric_limits<INT32>::max(), actual_r, actual_g - 1, actual_b + 1));
+ check_expected("rgbaint_t::cmpeq");
+
+ // test immediate equality comparison
+ actual_a = random_i32_nolimit();
+ actual_r = random_i32_nolimit();
+ actual_g = random_i32_nolimit();
+ actual_b = random_i32_nolimit();
+ expected_a = ~INT32(0);
+ expected_r = (actual_r == actual_a) ? ~INT32(0) : 0;
+ expected_g = (actual_g == actual_a) ? ~INT32(0) : 0;
+ expected_b = (actual_b == actual_a) ? ~INT32(0) : 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpeq_imm(actual_a);
+ check_expected("rgbaint_t::cmpeq_imm");
+ expected_a = (actual_a == actual_r) ? ~INT32(0) : 0;
+ expected_r = ~INT32(0);
+ expected_g = (actual_g == actual_r) ? ~INT32(0) : 0;
+ expected_b = (actual_b == actual_r) ? ~INT32(0) : 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpeq_imm(actual_r);
+ check_expected("rgbaint_t::cmpeq_imm");
+ expected_a = (actual_a == actual_g) ? ~INT32(0) : 0;
+ expected_r = (actual_r == actual_g) ? ~INT32(0) : 0;
+ expected_g = ~INT32(0);
+ expected_b = (actual_b == actual_g) ? ~INT32(0) : 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpeq_imm(actual_g);
+ check_expected("rgbaint_t::cmpeq_imm");
+ expected_a = (actual_a == actual_b) ? ~INT32(0) : 0;
+ expected_r = (actual_r == actual_b) ? ~INT32(0) : 0;
+ expected_g = (actual_g == actual_b) ? ~INT32(0) : 0;
+ expected_b = ~INT32(0);
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpeq_imm(actual_b);
+ check_expected("rgbaint_t::cmpeq_imm");
+ expected_a = 0;
+ expected_r = 0;
+ expected_g = 0;
+ expected_b = 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpeq_imm(std::numeric_limits<INT32>::min());
+ check_expected("rgbaint_t::cmpeq_imm");
+ expected_a = !actual_a ? ~INT32(0) : 0;
+ expected_r = !actual_r ? ~INT32(0) : 0;
+ expected_g = !actual_g ? ~INT32(0) : 0;
+ expected_b = !actual_b ? ~INT32(0) : 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpeq_imm(0);
+ check_expected("rgbaint_t::cmpeq_imm");
+ expected_a = 0;
+ expected_r = 0;
+ expected_g = 0;
+ expected_b = 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpeq_imm(std::numeric_limits<INT32>::max());
+ check_expected("rgbaint_t::cmpeq_imm");
+
+ // test immediate RGB equality comparison
+ actual_a = random_i32_nolimit();
+ actual_r = random_i32_nolimit();
+ actual_g = random_i32_nolimit();
+ actual_b = random_i32_nolimit();
+ expected_a = 0;
+ expected_r = 0;
+ expected_g = ~INT32(0);
+ expected_b = 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpeq_imm_rgba(std::numeric_limits<INT32>::min(), std::numeric_limits<INT32>::max(), actual_g, actual_b - 1);
+ check_expected("rgbaint_t::cmpeq_imm_rgba");
+ expected_a = 0;
+ expected_r = 0;
+ expected_g = 0;
+ expected_b = ~INT32(0);
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpeq_imm_rgba(actual_a + 1, std::numeric_limits<INT32>::min(), std::numeric_limits<INT32>::max(), actual_b);
+ check_expected("rgbaint_t::cmpeq_imm_rgba");
+
+ // test RGB greater than comparison
+ actual_a = random_i32_nolimit();
+ actual_r = random_i32_nolimit();
+ actual_g = random_i32_nolimit();
+ actual_b = random_i32_nolimit();
+ expected_a = 0;
+ expected_r = ~INT32(0);
+ expected_g = 0;
+ expected_b = ~INT32(0);
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpgt(rgbaint_t(actual_a, actual_r - 1, actual_g + 1, std::numeric_limits<INT32>::min()));
+ check_expected("rgbaint_t::cmpgt");
+ expected_a = 0;
+ expected_r = 0;
+ expected_g = ~INT32(0);
+ expected_b = 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpgt(rgbaint_t(std::numeric_limits<INT32>::max(), actual_r, actual_g - 1, actual_b + 1));
+ check_expected("rgbaint_t::cmpgt");
+
+ // test immediate greater than comparison
+ actual_a = random_i32_nolimit();
+ actual_r = random_i32_nolimit();
+ actual_g = random_i32_nolimit();
+ actual_b = random_i32_nolimit();
+ expected_a = 0;
+ expected_r = (actual_r > actual_a) ? ~INT32(0) : 0;
+ expected_g = (actual_g > actual_a) ? ~INT32(0) : 0;
+ expected_b = (actual_b > actual_a) ? ~INT32(0) : 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpgt_imm(actual_a);
+ check_expected("rgbaint_t::cmpgt_imm");
+ expected_a = (actual_a > actual_r) ? ~INT32(0) : 0;
+ expected_r = 0;
+ expected_g = (actual_g > actual_r) ? ~INT32(0) : 0;
+ expected_b = (actual_b > actual_r) ? ~INT32(0) : 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpgt_imm(actual_r);
+ check_expected("rgbaint_t::cmpgt_imm");
+ expected_a = (actual_a > actual_g) ? ~INT32(0) : 0;
+ expected_r = (actual_r > actual_g) ? ~INT32(0) : 0;
+ expected_g =0;
+ expected_b = (actual_b > actual_g) ? ~INT32(0) : 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpgt_imm(actual_g);
+ check_expected("rgbaint_t::cmpgt_imm");
+ expected_a = (actual_a > actual_b) ? ~INT32(0) : 0;
+ expected_r = (actual_r > actual_b) ? ~INT32(0) : 0;
+ expected_g = (actual_g > actual_b) ? ~INT32(0) : 0;
+ expected_b = 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpgt_imm(actual_b);
+ check_expected("rgbaint_t::cmpgt_imm");
+ expected_a = ~INT32(0);
+ expected_r = ~INT32(0);
+ expected_g = ~INT32(0);
+ expected_b = ~INT32(0);
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpgt_imm(std::numeric_limits<INT32>::min());
+ check_expected("rgbaint_t::cmpgt_imm");
+ expected_a = (actual_a > 0) ? ~INT32(0) : 0;
+ expected_r = (actual_r > 0) ? ~INT32(0) : 0;
+ expected_g = (actual_g > 0) ? ~INT32(0) : 0;
+ expected_b = (actual_b > 0) ? ~INT32(0) : 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpgt_imm(0);
+ check_expected("rgbaint_t::cmpgt_imm");
+ expected_a = 0;
+ expected_r = 0;
+ expected_g = 0;
+ expected_b = 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpgt_imm(std::numeric_limits<INT32>::max());
+ check_expected("rgbaint_t::cmpgt_imm");
+
+ // test immediate RGB greater than comparison
+ actual_a = random_i32_nolimit();
+ actual_r = random_i32_nolimit();
+ actual_g = random_i32_nolimit();
+ actual_b = random_i32_nolimit();
+ expected_a = ~INT32(0);
+ expected_r = 0;
+ expected_g = 0;
+ expected_b = ~INT32(0);
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpgt_imm_rgba(std::numeric_limits<INT32>::min(), std::numeric_limits<INT32>::max(), actual_g, actual_b - 1);
+ check_expected("rgbaint_t::cmpgt_imm_rgba");
+ expected_a = 0;
+ expected_r = ~INT32(0);
+ expected_g = 0;
+ expected_b = 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmpgt_imm_rgba(actual_a + 1, std::numeric_limits<INT32>::min(), std::numeric_limits<INT32>::max(), actual_b);
+ check_expected("rgbaint_t::cmpgt_imm_rgba");
+
+ // test RGB less than comparison
+ actual_a = random_i32_nolimit();
+ actual_r = random_i32_nolimit();
+ actual_g = random_i32_nolimit();
+ actual_b = random_i32_nolimit();
+ expected_a = 0;
+ expected_r = 0;
+ expected_g = ~INT32(0);
+ expected_b = 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmplt(rgbaint_t(actual_a, actual_r - 1, actual_g + 1, std::numeric_limits<INT32>::min()));
+ check_expected("rgbaint_t::cmplt");
+ expected_a = ~INT32(0);
+ expected_r = 0;
+ expected_g = 0;
+ expected_b = ~INT32(0);
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmplt(rgbaint_t(std::numeric_limits<INT32>::max(), actual_r, actual_g - 1, actual_b + 1));
+ check_expected("rgbaint_t::cmplt");
+
+ // test immediate less than comparison
+ actual_a = random_i32_nolimit();
+ actual_r = random_i32_nolimit();
+ actual_g = random_i32_nolimit();
+ actual_b = random_i32_nolimit();
+ expected_a = 0;
+ expected_r = (actual_r < actual_a) ? ~INT32(0) : 0;
+ expected_g = (actual_g < actual_a) ? ~INT32(0) : 0;
+ expected_b = (actual_b < actual_a) ? ~INT32(0) : 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmplt_imm(actual_a);
+ check_expected("rgbaint_t::cmplt_imm");
+ expected_a = (actual_a < actual_r) ? ~INT32(0) : 0;
+ expected_r = 0;
+ expected_g = (actual_g < actual_r) ? ~INT32(0) : 0;
+ expected_b = (actual_b < actual_r) ? ~INT32(0) : 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmplt_imm(actual_r);
+ check_expected("rgbaint_t::cmplt_imm");
+ expected_a = (actual_a < actual_g) ? ~INT32(0) : 0;
+ expected_r = (actual_r < actual_g) ? ~INT32(0) : 0;
+ expected_g =0;
+ expected_b = (actual_b < actual_g) ? ~INT32(0) : 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmplt_imm(actual_g);
+ check_expected("rgbaint_t::cmplt_imm");
+ expected_a = (actual_a < actual_b) ? ~INT32(0) : 0;
+ expected_r = (actual_r < actual_b) ? ~INT32(0) : 0;
+ expected_g = (actual_g < actual_b) ? ~INT32(0) : 0;
+ expected_b = 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmplt_imm(actual_b);
+ check_expected("rgbaint_t::cmplt_imm");
+ expected_a = 0;
+ expected_r = 0;
+ expected_g = 0;
+ expected_b = 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmplt_imm(std::numeric_limits<INT32>::min());
+ check_expected("rgbaint_t::cmplt_imm");
+ expected_a = (actual_a < 0) ? ~INT32(0) : 0;
+ expected_r = (actual_r < 0) ? ~INT32(0) : 0;
+ expected_g = (actual_g < 0) ? ~INT32(0) : 0;
+ expected_b = (actual_b < 0) ? ~INT32(0) : 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmplt_imm(0);
+ check_expected("rgbaint_t::cmplt_imm");
+ expected_a = ~INT32(0);
+ expected_r = ~INT32(0);
+ expected_g = ~INT32(0);
+ expected_b = ~INT32(0);
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmplt_imm(std::numeric_limits<INT32>::max());
+ check_expected("rgbaint_t::cmplt_imm");
+
+ // test immediate RGB less than comparison
+ actual_a = random_i32_nolimit();
+ actual_r = random_i32_nolimit();
+ actual_g = random_i32_nolimit();
+ actual_b = random_i32_nolimit();
+ expected_a = 0;
+ expected_r = ~INT32(0);
+ expected_g = 0;
+ expected_b = 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmplt_imm_rgba(std::numeric_limits<INT32>::min(), std::numeric_limits<INT32>::max(), actual_g, actual_b - 1);
+ check_expected("rgbaint_t::cmplt_imm_rgba");
+ expected_a = ~INT32(0);
+ expected_r = 0;
+ expected_g = ~INT32(0);
+ expected_b = 0;
+ rgb.set(actual_a, actual_r, actual_g, actual_b);
+ rgb.cmplt_imm_rgba(actual_a + 1, std::numeric_limits<INT32>::min(), std::numeric_limits<INT32>::max(), actual_b);
+ check_expected("rgbaint_t::cmplt_imm_rgba");
}