remove obsolete thing that never worked

[scpubgit/Q-Branch.git] / t / 23_is_X_value.t

diff --git a/t/23_is_X_value.t b/t/23_is_X_value.t
index d52d228..c43b3a3 100644 (file)
--- a/t/23_is_X_value.t
+++ b/t/23_is_X_value.t
@@ -6,8 +6,30 @@ use Test::Exception;
 use Scalar::Util 'refaddr';
 use Storable 'nfreeze';
 
+BEGIN { $ENV{SQLA_ISVALUE_IGNORE_AUTOGENERATED_STRINGIFICATION} = 0 }
+
 use SQL::Abstract qw(is_plain_value is_literal_value);
 
+# fallback setting is inheriting starting p5 50853fa9 (run up to 5.17.0)
+use constant OVERLOAD_FALLBACK_INHERITS => ( ($] < 5.017) ? 0 : 1 );
+use constant STRINGIFIER_CAN_RETURN_IVS => ( ($] < 5.008) ? 0 : 1 );
+
+{
+  package # hideee
+    SQLATest::SillyBool;
+
+  use overload
+    # *DELIBERATELY* unspecified
+    #fallback => 1,
+    bool => sub { ${$_[0]} },
+  ;
+
+  package # hideee
+    SQLATest::SillyBool::Subclass;
+
+  our @ISA = 'SQLATest::SillyBool';
+}
+
 {
   package # hideee
     SQLATest::SillyInt;
@@ -44,6 +66,25 @@ use SQL::Abstract qw(is_plain_value is_literal_value);
 }
 
 {
+  package # hideee
+    SQLATest::AnalInt;
+
+  use overload
+    fallback => 0,
+    '0+' => sub { ${$_[0]} },
+  ;
+
+  package # hideee
+    SQLATest::AnalInt::Subclass;
+
+  use overload
+    '0+' => sub { ${$_[0]} },
+  ;
+
+  our @ISA = 'SQLATest::AnalInt';
+}
+
+{
   package # hidee
     SQLATest::ReasonableInt;
 
@@ -54,18 +95,44 @@ use SQL::Abstract qw(is_plain_value is_literal_value);
     '--' => sub { $_[0] = ${$_[0]} - 1 },
     fallback => 1,
   ;
+
+  package # hideee
+    SQLATest::ReasonableInt::Subclass;
+
+  our @ISA = 'SQLATest::ReasonableInt';
+}
+
+{
+  package # hidee
+    SQLATest::ReasonableString;
+
+  # somewhat like DateTime
+  use overload
+    'fallback' => 1,
+    '""'       => sub { "${$_[0]}" },
+    '-'        => sub { ${$_[0]} - $_[1] },
+    '+'        => sub { ${$_[0]} + $_[1] },
+  ;
+
+  package # hideee
+    SQLATest::ReasonableString::Subclass;
+
+  our @ISA = 'SQLATest::ReasonableString';
 }
 
 for my $case (
+  { class => 'SQLATest::SillyBool',           can_math => 0, should_str => 1 },
+  { class => 'SQLATest::SillyBool::Subclass', can_math => 0, should_str => 1 },
   { class => 'SQLATest::SillyInt',            can_math => 0, should_str => 1 },
   { class => 'SQLATest::SillyInt::Subclass',  can_math => 0, should_str => 1 },
   { class => 'SQLATest::SillierInt',          can_math => 0, should_str => 0 },
-  { class => 'SQLATest::SillierInt::Subclass',
-    ($] < 5.017)  # fallback is inheriting starting p5 50853fa9 (run up to 5.17.0)
-    ? ( can_math => 1, should_str => 1 )
-    : ( can_math => 1, should_str => 0 )
-  },
-  { class => 'SQLATest::ReasonableInt',       can_math => 1, should_str => 1 },
+  { class => 'SQLATest::SillierInt::Subclass',can_math => 1, should_str => (OVERLOAD_FALLBACK_INHERITS ? 0 : 1) },
+  { class => 'SQLATest::AnalInt',             can_math => 0, should_str => 0 },
+  { class => 'SQLATest::AnalInt::Subclass',   can_math => 0, should_str => (OVERLOAD_FALLBACK_INHERITS ? 0 : 1) },
+  { class => 'SQLATest::ReasonableInt',             can_math => 1, should_str => 1 },
+  { class => 'SQLATest::ReasonableInt::Subclass',   can_math => 1, should_str => 1 },
+  { class => 'SQLATest::ReasonableString',          can_math => 1, should_str => 1 },
+  { class => 'SQLATest::ReasonableString::Subclass',can_math => 1, should_str => 1 },
 ) {
 
   my $num = bless( \do { my $foo = 42 }, $case->{class} );
@@ -84,7 +151,7 @@ for my $case (
     "can_math setting for $case->{class} matches perl behavior",
   ) || diag explain { %$case, actual_can_math => $can_math };
 
-  my $can_cmp = eval { my $dum = $num eq "nope"; 1 } || 0;
+  my $can_cmp = eval { my $dum = ($num eq "nope"); 1 } || 0;
 
   for (1,2) {
 
@@ -92,10 +159,10 @@ for my $case (
 
       ok $num, 'bool ctx works';
 
-      if ($can_cmp) {
+      if (STRINGIFIER_CAN_RETURN_IVS and $can_cmp) {
         is_deeply(
           is_plain_value $num,
-          [ $num ],
+          \$num,
           "stringification detected on $case->{class}",
         ) || diag explain $case;
       }
@@ -103,13 +170,13 @@ for my $case (
         # is_deeply does not do nummify/stringify cmps properly
         # but we can always compare the ice
         ok(
-          ( nfreeze( is_plain_value $num ) eq nfreeze( [ $num ] ) ),
+          ( nfreeze( is_plain_value $num ) eq nfreeze( \$num ) ),
           "stringification without cmp capability detected on $case->{class}"
         ) || diag explain $case;
       }
 
       is (
-        refaddr(is_plain_value($num)->[0]),
+        refaddr( ${is_plain_value($num)} ),
         refaddr $num,
         "Same reference (blessed object) returned",
       );
@@ -131,7 +198,7 @@ lives_ok {
   cmp_ok(--$num, 'eq', 23, 'test overloaded object compares correctly');
   is_deeply(
     is_plain_value $num,
-    [ 23 ],
+    \23,
     'fallback stringification detected'
   );
   cmp_ok(--$num, 'eq', 22, 'test overloaded object compares correctly');
@@ -141,7 +208,7 @@ lives_ok {
 
 is_deeply
   is_plain_value {  -value => [] },
-  [ [] ],
+  \[],
   '-value recognized'
 ;
 
@@ -156,21 +223,21 @@ for ([], {}, \'') {
 for (undef, { -value => undef }) {
   is_deeply
     is_plain_value $_,
-    [ undef ],
+    \undef,
     'NULL -value recognized'
   ;
 }
 
 is_deeply
-  is_literal_value { -ident => 'foo' },
-  [ 'foo' ],
-  '-ident recognized as literal'
+  is_literal_value \'sql',
+  [ 'sql' ],
+  'literal correctly recognized and unpacked'
 ;
 
 is_deeply
   is_literal_value \[ 'sql', 'bind1', [ {} => 'bind2' ] ],
   [ 'sql', 'bind1', [ {} => 'bind2' ] ],
-  'literal correctly unpacked'
+  'literal with binds correctly recognized and unpacked'
 ;