Retro68/gcc/libjava/testsuite/libjava.special/special.exp

# Special test cases.  These require tricky build procedures.

proc gcj_special_try_compiler {} {
  global srcdir subdir
  return [bytecompile_file ${srcdir}/${subdir}/pr21115I.java [pwd]]
}

proc gcj_special_pr21115 {} {
  global srcdir subdir env

  # ---- PR 21115 -------------------------------------------------------

  if {! [bytecompile_file ${srcdir}/${subdir}/pr21115I.java [pwd]]} {
    fail "bytecompile ${srcdir}/${subdir}/libjava.special/pr21115I.java"
    # FIXME - should use `untested' on all remaining tests.
    # But that is hard.
    return 0
  }
  pass "bytecompile pr21115I.java"

  if {! [gcj_link pr21115 pr21115 [list ${srcdir}/${subdir}/pr21115.java]]} {
    fail "compiling/linking pr21115.java"
    # FIXME
    return 0
  }

  if {! [gcj_invoke pr21115 ${srcdir}/${subdir}/pr21115.out ""]} {
    # FIXME
    return 0
  }

  return 1
}

# Write a .java file and bytecompile it.  Return 0 on failure.
proc gcj_write_and_byte_compile {name contents} {
  set fd [open $name w]
  puts $fd $contents
  close $fd

  if {! [bytecompile_file $name [pwd]]} {
    fail "bytecompile $name"
    # FIXME - should use `untested' on all remaining tests.
    # But that is hard.
    return 0
  }
  pass "bytecompile $name"
  return 1
}

# Check that BC-compiled code lazily throws IllegalAccessError.
proc gcj_special_lazy_illegal_access {} {
  global srcdir subdir env

  # Write and compile the initial files.
  if {! [gcj_write_and_byte_compile LazyA.java {
    public class LazyA {
      public static void m() { }
    }
  }]} {
    return 0
  }
  if {! [gcj_write_and_byte_compile LazyB.java {
    public class LazyB {
      public static void m() { }
      public static void main(String[] args) { }
    }
  }]} {
    return 0
  }

  # Create the expected output file.
  set fd [open Lazy.out w]
  close $fd

  # Now recompile LazyA with different access for m().
  if {! [gcj_write_and_byte_compile LazyA.java {
    public class LazyA {
      private static void m() { }
    }
  }]} {
    return 0
  }

  # Link and run... this should still work, since we don't actually
  # try to call LazyA.m().
  if {! [gcj_link Lazy LazyB {LazyA.class LazyB.class} \
	   additional_flags=-findirect-dispatch]} {
    fail "compiling/linking pr21115.java"
    # FIXME
    return 0
  }

  if {! [gcj_invoke Lazy Lazy.out ""]} {
    # FIXME
    return 0
  }

  return 1
}

# For these tests it is simpler to require that gcj work.  So we try
# the compiler and if it fails, we simply skip the tests.

if {[gcj_special_try_compiler]} {
  gcj_special_pr21115
  gcj_special_lazy_illegal_access
}