class TestCase::Operator::SpecialAssign {
  use TestCase::Minimal;
  use TestCase::Simple;
  use TestCase::Point_3b;
  use TestCase::Point_3s;
  use TestCase::Point_3i;
  use TestCase::Point_3l;
  use TestCase::Point_3f;
  use TestCase::Point_3d;
  use Fn;
  use Array;
  use Point;
  
  our $BYTE_VALUE : byte;
  our $SHORT_VALUE : short;
  our $INT_VALUE : int;
  our $LONG_VALUE : long;
  our $FLOAT_VALUE : float;
  our $DOUBLE_VALUE : double;

  static method special_assign_right_shift_unsigned_var : int () {
    my $value_byte = Fn->INT8_MIN();
    my $value_short = Fn->INT16_MIN();
    my $value_int = Fn->INT32_MIN();
    my $value_long = Fn->INT64_MIN();
    
    my $value_byte2 : byte = $value_byte >>>= 1;
    my $value_short2 : short = $value_short >>>= 1;
    my $value_int2 : int = $value_int >>>= 1;
    my $value_long2 : long = $value_long >>>= 1;
    
    unless ($value_byte == Fn->INT8_MIN() >>> 1) {
      return 0;
    }
    unless ($value_byte2 == Fn->INT8_MIN() >>> 1) {
      return 0;
    }
    unless ($value_short == Fn->INT16_MIN() >>> 1) {
      return 0;
    }
    unless ($value_short2 == Fn->INT16_MIN() >>> 1) {
      return 0;
    }
    unless ($value_int == Fn->INT32_MIN() >>> 1) {
      return 0;
    }
    unless ($value_int2 == Fn->INT32_MIN() >>> 1) {
      return 0;
    }
    unless ($value_long == Fn->INT64_MIN() >>> 1) {
      return 0;
    }
    unless ($value_long2 == Fn->INT64_MIN() >>> 1) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_right_shift_var : int () {
    my $value_byte = Fn->INT8_MIN();
    my $value_short = Fn->INT16_MIN();
    my $value_int = Fn->INT32_MIN();
    my $value_long = Fn->INT64_MIN();
    
    my $value_byte2 : byte = $value_byte >>= 1;
    my $value_short2 : short = $value_short >>= 1;
    my $value_int2 : int = $value_int >>= 1;
    my $value_long2 : long = $value_long >>= 1;
    
    unless ($value_byte == Fn->INT8_MIN() >> 1) {
      return 0;
    }
    unless ($value_byte2 == Fn->INT8_MIN() >> 1) {
      return 0;
    }
    unless ($value_short == Fn->INT16_MIN() >> 1) {
      return 0;
    }
    unless ($value_short2 == Fn->INT16_MIN() >> 1) {
      return 0;
    }
    unless ($value_int == Fn->INT32_MIN() >> 1) {
      return 0;
    }
    unless ($value_int2 == Fn->INT32_MIN() >> 1) {
      return 0;
    }
    unless ($value_long == Fn->INT64_MIN() >> 1) {
      return 0;
    }
    unless ($value_long2 == Fn->INT64_MIN() >> 1) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_left_shift_var : int () {
    my $value_byte = (byte)6;
    my $value_short = (short)6;
    my $value_int = 6;
    my $value_long = 6;
    
    my $value_byte2 : byte = $value_byte <<= 1;
    my $value_short2 : short = $value_short <<= 1;
    my $value_int2 : int = $value_int <<= 1;
    my $value_long2 : long = $value_long <<= 1;
    
    unless ($value_byte == 6 << 1) {
      return 0;
    }
    unless ($value_byte2 == 6 << 1) {
      return 0;
    }
    unless ($value_short == 6 << 1) {
      return 0;
    }
    unless ($value_short2 == 6 << 1) {
      return 0;
    }
    unless ($value_int == 6 << 1) {
      return 0;
    }
    unless ($value_int2 == 6 << 1) {
      return 0;
    }
    unless ($value_long == 6 << 1) {
      return 0;
    }
    unless ($value_long2 == 6 << 1) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_bit_xor_var : int () {
    my $value_byte = (byte)6;
    my $value_short = (short)6;
    my $value_int = 6;
    my $value_long = 6;
    
    my $value_byte2 : byte = $value_byte ^= 3;
    my $value_short2 : short = $value_short ^= 3;
    my $value_int2 : int = $value_int ^= 3;
    my $value_long2 : long = $value_long ^= 3;
    
    unless ($value_byte == (6 ^ 3)) {
      return 0;
    }
    unless ($value_byte2 == (6 ^ 3)) {
      return 0;
    }
    unless ($value_short == (6 ^ 3)) {
      return 0;
    }
    unless ($value_short2 == (6 ^ 3)) {
      return 0;
    }
    unless ($value_int == (6 ^ 3)) {
      return 0;
    }
    unless ($value_int2 == (6 ^ 3)) {
      return 0;
    }
    unless ($value_long == (6 ^ 3)) {
      return 0;
    }
    unless ($value_long2 == (6 ^ 3)) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_bit_or_var : int () {
    my $value_byte = (byte)6;
    my $value_short = (short)6;
    my $value_int = 6;
    my $value_long = 6;
    
    my $value_byte2 : byte = $value_byte |= 3;
    my $value_short2 : short = $value_short |= 3;
    my $value_int2 : int = $value_int |= 3;
    my $value_long2 : long = $value_long |= 3;
    
    unless ($value_byte == (6 | 3)) {
      return 0;
    }
    unless ($value_byte2 == (6 | 3)) {
      return 0;
    }
    unless ($value_short == (6 | 3)) {
      return 0;
    }
    unless ($value_short2 == (6 | 3)) {
      return 0;
    }
    unless ($value_int == (6 | 3)) {
      return 0;
    }
    unless ($value_int2 == (6 | 3)) {
      return 0;
    }
    unless ($value_long == (6 | 3)) {
      return 0;
    }
    unless ($value_long2 == (6 | 3)) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_bit_and_var : int () {
    my $value_byte = (byte)6;
    my $value_short = (short)6;
    my $value_int = 6;
    my $value_long = 6;
    
    my $value_byte2 : byte = $value_byte &= 3;
    my $value_short2 : short = $value_short &= 3;
    my $value_int2 : int = $value_int &= 3;
    my $value_long2 : long = $value_long &= 3;
    
    unless ($value_byte == (6 & 3)) {
      return 0;
    }
    unless ($value_byte2 == (6 & 3)) {
      return 0;
    }
    unless ($value_short == (6 & 3)) {
      return 0;
    }
    unless ($value_short2 == (6 & 3)) {
      return 0;
    }
    unless ($value_int == (6 & 3)) {
      return 0;
    }
    unless ($value_int2 == (6 & 3)) {
      return 0;
    }
    unless ($value_long == (6 & 3)) {
      return 0;
    }
    
    return 1;
  }
  
  static method special_assign_modulo_var : int () {
    my $value_byte = (byte)6;
    my $value_short = (short)6;
    my $value_int = 6;
    my $value_long = 6L;
    my $value_float = 0.25f;
    my $value_double = 0.25;
    
    my $value_byte2 : byte = $value_byte %= 3;
    my $value_short2 : short = $value_short %= 3;
    my $value_int2 : int = $value_int %= 3;
    my $value_long2 : long = $value_long %= 3;
    
    unless ($value_byte == 6 % 3) {
      return 0;
    }
    unless ($value_byte2 == 6 % 3) {
      return 0;
    }
    unless ($value_short == 6 % 3) {
      return 0;
    }
    unless ($value_short2 == 6 % 3) {
      return 0;
    }
    unless ($value_int == 6 % 3) {
      return 0;
    }
    unless ($value_int2 == 6 % 3) {
      return 0;
    }
    unless ($value_long == 6 % 3) {
      return 0;
    }
    unless ($value_long2 == 6 % 3) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_divide_var : int () {
    my $value_byte = (byte)6;
    my $value_short = (short)6;
    my $value_int = 6;
    my $value_long = 6L;
    my $value_float = 0.25f;
    my $value_double = 0.25;
    
    my $value_byte2 : byte = $value_byte /= 3;
    my $value_short2 : short = $value_short /= 3;
    my $value_int2 : int = $value_int /= 3;
    my $value_long2 : long = $value_long /= 3;
    my $value_float2 : float = $value_float /= 3;
    my $value_double2 : double= $value_double /= 3;
    
    unless ($value_byte == 6 / 3) {
      return 0;
    }
    unless ($value_byte2 == 6 / 3) {
      return 0;
    }
    unless ($value_short == 6 / 3) {
      return 0;
    }
    unless ($value_short2 == 6 / 3) {
      return 0;
    }
    unless ($value_int == 6 / 3) {
      return 0;
    }
    unless ($value_int2 == 6 / 3) {
      return 0;
    }
    unless ($value_long == 6 / 3) {
      return 0;
    }
    unless ($value_long2 == 6 / 3) {
      return 0;
    }
    unless ($value_float == 0.25f / 3) {
      return 0;
    }
    unless ($value_float2 == 0.25f / 3) {
      return 0;
    }
    unless ($value_double == 0.25 / 3) {
      return 0;
    }
    unless ($value_double2 = 0.25 / 3) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_multiply_var : int () {
    my $value_byte = (byte)6;
    my $value_short = (short)6;
    my $value_int = 6;
    my $value_long = 6L;
    my $value_float = 0.25f;
    my $value_double = 0.25;
    
    my $value_byte2 : byte = $value_byte *= 3;
    my $value_short2 : short = $value_short *= 3;
    my $value_int2 : int = $value_int *= 3;
    my $value_long2 : long = $value_long *= 3;
    my $value_float2 : float = $value_float *= 3;
    my $value_double2 : double= $value_double *= 3;
    
    unless ($value_byte == 6 * 3) {
      return 0;
    }
    unless ($value_byte2 == 6 * 3) {
      return 0;
    }
    unless ($value_short == 6 * 3) {
      return 0;
    }
    unless ($value_short2 == 6 * 3) {
      return 0;
    }
    unless ($value_int == 6 * 3) {
      return 0;
    }
    unless ($value_int2 == 6 * 3) {
      return 0;
    }
    unless ($value_long == 6 * 3) {
      return 0;
    }
    unless ($value_long2 == 6 * 3) {
      return 0;
    }
    unless ($value_float == 0.25f * 3) {
      return 0;
    }
    unless ($value_float2 == 0.25f * 3) {
      return 0;
    }
    unless ($value_double == 0.25 * 3) {
      return 0;
    }
    unless ($value_double2 = 0.25 * 3) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_subtract_var : int () {
    my $value_byte = Fn->INT8_MAX();
    my $value_short = Fn->INT16_MAX();
    my $value_int = Fn->INT32_MAX();
    my $value_long = Fn->INT64_MAX();
    my $value_float = Fn->FLT_MAX();
    my $value_double = Fn->DBL_MAX();
    
    my $value_byte2 : byte = $value_byte -=1;
    my $value_short2 : short = $value_short -=1;
    my $value_int2 : int = $value_int -=1;
    my $value_long2 : long = $value_long -=1;
    my $value_float2 : float = $value_float -=1;
    my $value_double2 : double= $value_double -=1;
    
    unless ($value_byte == Fn->INT8_MAX() - 1) {
      return 0;
    }
    unless ($value_byte2 == Fn->INT8_MAX() - 1) {
      return 0;
    }
    unless ($value_short == Fn->INT16_MAX() - 1) {
      return 0;
    }
    unless ($value_short2 == Fn->INT16_MAX() - 1) {
      return 0;
    }
    unless ($value_int == Fn->INT32_MAX() - 1) {
      return 0;
    }
    unless ($value_int2 == Fn->INT32_MAX() - 1) {
      return 0;
    }
    unless ($value_long == Fn->INT64_MAX() - 1) {
      return 0;
    }
    unless ($value_long2 == Fn->INT64_MAX() - 1) {
      return 0;
    }
    unless ($value_float == Fn->FLT_MAX() - 1) {
      return 0;
    }
    unless ($value_float2 == Fn->FLT_MAX() - 1) {
      return 0;
    }
    unless ($value_double == Fn->DBL_MAX() - 1) {
      return 0;
    }
    unless ($value_double2 = Fn->DBL_MAX() - 1) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_add_field_access_invocant_not_var : int () {
    my $nums_of_nums = new TestCase::Minimal[2];
    $nums_of_nums->[0] = TestCase::Minimal->new;
    
    my $ret1 = $nums_of_nums->[0]{x} += 1;
    
    unless ($nums_of_nums->[0]{x} == 1) {
      return 0;
    }
    
    unless ($ret1 == 1) {
      return 0;
    }
    
    return 1;
  }
  
  static method special_assign_add_element_access_invocant_not_var : int () {
    my $nums_of_nums = new int[][2];
    $nums_of_nums->[0] = new int[1];
    
    my $ret1 = $nums_of_nums->[0][0] += 1;
    
    unless ($nums_of_nums->[0][0] == 1) {
      return 0;
    }
    
    unless ($ret1 == 1) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_add_array_field_access_invocant_not_var : int () {
    my $nums_of_nums = new TestCase::Point_3i[][2];
    $nums_of_nums->[0] = new TestCase::Point_3i[1];
    
    my $ret1 = $nums_of_nums->[0][0]{x} += 1;
    
    unless ($nums_of_nums->[0][0]{x} == 1) {
      return 0;
    }
    
    unless ($ret1 == 1) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_add_array_field_access_constant_index : int () {
    my $values_point_byte = new TestCase::Point_3b[1];
    my $values_point_short = new TestCase::Point_3s[1];
    my $values_point_int = new TestCase::Point_3i[1];
    my $values_point_long = new TestCase::Point_3l[1];
    my $values_point_float = new TestCase::Point_3f[1];
    my $values_point_double = new TestCase::Point_3d[1];
    
    $values_point_byte->[0]{x} = Fn->INT8_MIN();
    $values_point_short->[0]{x} = Fn->INT16_MIN();
    $values_point_int->[0]{x} = Fn->INT32_MIN();
    $values_point_long->[0]{x} = Fn->INT64_MIN();
    $values_point_float->[0]{x} = Fn->FLT_MIN();
    $values_point_double->[0]{x} = Fn->DBL_MIN();

    my $value_byte2 = $values_point_byte->[0]{x} += 1;
    my $value_short2 = $values_point_short->[0]{x} += 1;
    my $value_int2 = $values_point_int->[0]{x} += 1;
    my $value_long2 = $values_point_long->[0]{x} += 1;
    my $value_float2 = $values_point_float->[0]{x} += 1;
    my $value_double2 = $values_point_double->[0]{x} += 1;
    
    unless ($values_point_byte->[0]{x} == Fn->INT8_MIN() + 1) {
      return 0;
    }
    unless ($value_byte2 == Fn->INT8_MIN() + 1) {
      return 0;
    }
    unless ($values_point_short->[0]{x} == Fn->INT16_MIN() + 1) {
      return 0;
    }
    unless ($value_short2 == Fn->INT16_MIN() + 1) {
      return 0;
    }
    unless ($values_point_int->[0]{x} == Fn->INT32_MIN() + 1) {
      return 0;
    }
    unless ($value_int2 == Fn->INT32_MIN() + 1) {
      return 0;
    }
    unless ($values_point_long->[0]{x} == Fn->INT64_MIN() + 1) {
      return 0;
    }
    unless ($value_long2 == Fn->INT64_MIN() + 1) {
      return 0;
    }
    unless ($values_point_float->[0]{x} == Fn->FLT_MIN() + 1) {
      return 0;
    }
    unless ($value_float2 == Fn->FLT_MIN() + 1) {
      return 0;
    }
    unless ($values_point_double->[0]{x} == Fn->DBL_MIN() + 1) {
      return 0;
    }
    unless ($value_double2 = Fn->DBL_MIN() + 1) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_add_class_var_access : int () {
    $BYTE_VALUE = Fn->INT8_MIN();
    $SHORT_VALUE = Fn->INT16_MIN();
    $INT_VALUE = Fn->INT32_MIN();
    $LONG_VALUE = Fn->INT64_MIN();
    $FLOAT_VALUE = Fn->FLT_MIN();
    $DOUBLE_VALUE = Fn->DBL_MIN();
    
    my $value_byte2 = $BYTE_VALUE += 1;
    my $value_short2 = $SHORT_VALUE += 1;
    my $value_int2 = $INT_VALUE += 1;
    my $value_long2 = $LONG_VALUE += 1;
    my $value_float2 = $FLOAT_VALUE += 1;
    my $value_double2 = $DOUBLE_VALUE += 1;
    
    unless ($BYTE_VALUE == Fn->INT8_MIN() + 1) {
      return 0;
    }
    unless ($value_byte2 == Fn->INT8_MIN() + 1) {
      return 0;
    }
    unless ($SHORT_VALUE == Fn->INT16_MIN() + 1) {
      return 0;
    }
    unless ($value_short2 == Fn->INT16_MIN() + 1) {
      return 0;
    }
    unless ($INT_VALUE == Fn->INT32_MIN() + 1) {
      return 0;
    }
    unless ($value_int2 == Fn->INT32_MIN() + 1) {
      return 0;
    }
    unless ($LONG_VALUE == Fn->INT64_MIN() + 1) {
      return 0;
    }
    unless ($value_long2 == Fn->INT64_MIN() + 1) {
      return 0;
    }
    unless ($FLOAT_VALUE == Fn->FLT_MIN() + 1) {
      return 0;
    }
    unless ($value_float2 == Fn->FLT_MIN() + 1) {
      return 0;
    }
    unless ($DOUBLE_VALUE == Fn->DBL_MIN() + 1) {
      return 0;
    }
    unless ($value_double2 = Fn->DBL_MIN() + 1) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_add_deref : int () {
    my $value_byte = Fn->INT8_MIN();
    my $value_short = Fn->INT16_MIN();
    my $value_int = Fn->INT32_MIN();
    my $value_long = Fn->INT64_MIN();
    my $value_float = Fn->FLT_MIN();
    my $value_double = Fn->DBL_MIN();
    
    my $value_byte_ref = \$value_byte;
    my $value_short_ref = \$value_short;
    my $value_int_ref = \$value_int;
    my $value_long_ref = \$value_long;
    my $value_float_ref = \$value_float;
    my $value_double_ref = \$value_double;
    
    my $value_byte2 = $$value_byte_ref += 1;
    my $value_short2 = $$value_short_ref += 1;
    my $value_int2 = $$value_int_ref += 1;
    my $value_long2 = $$value_long_ref += 1;
    my $value_float2 = $$value_float_ref += 1;
    my $value_double2 = $$value_double_ref += 1;
    
    unless ($$value_byte_ref == Fn->INT8_MIN() + 1) {
      return 0;
    }
    unless ($value_byte2 == Fn->INT8_MIN() + 1) {
      return 0;
    }
    unless ($$value_short_ref == Fn->INT16_MIN() + 1) {
      return 0;
    }
    unless ($value_short2 == Fn->INT16_MIN() + 1) {
      return 0;
    }
    unless ($$value_int_ref == Fn->INT32_MIN() + 1) {
      return 0;
    }
    unless ($value_int2 == Fn->INT32_MIN() + 1) {
      return 0;
    }
    unless ($$value_long_ref == Fn->INT64_MIN() + 1) {
      return 0;
    }
    unless ($value_long2 == Fn->INT64_MIN() + 1) {
      return 0;
    }
    unless ($$value_float_ref == Fn->FLT_MIN() + 1) {
      return 0;
    }
    unless ($value_float2 == Fn->FLT_MIN() + 1) {
      return 0;
    }
    unless ($$value_double_ref == Fn->DBL_MIN() + 1) {
      return 0;
    }
    unless ($value_double2 = Fn->DBL_MIN() + 1) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_add_field_access : int () {
    my $simple = TestCase::Simple->new;
    
    $simple->{byte_value} = Fn->INT8_MIN();
    $simple->{short_value} = Fn->INT16_MIN();
    $simple->{int_value} = Fn->INT32_MIN();
    $simple->{long_value} = Fn->INT64_MIN();
    $simple->{float_value} = Fn->FLT_MIN();
    $simple->{double_value} = Fn->DBL_MIN();

    my $value_byte2 = $simple->{byte_value} += 1;
    my $value_short2 = $simple->{short_value} += 1;
    my $value_int2 = $simple->{int_value} += 1;
    my $value_long2 = $simple->{long_value} += 1;
    my $value_float2 = $simple->{float_value} += 1;
    my $value_double2 = $simple->{double_value} += 1;
    
    unless ($simple->{byte_value} == Fn->INT8_MIN() + 1) {
      return 0;
    }
    unless ($value_byte2 == Fn->INT8_MIN() + 1) {
      return 0;
    }
    unless ($simple->{short_value} == Fn->INT16_MIN() + 1) {
      return 0;
    }
    unless ($value_short2 == Fn->INT16_MIN() + 1) {
      return 0;
    }
    unless ($simple->{int_value} == Fn->INT32_MIN() + 1) {
      return 0;
    }
    unless ($value_int2 == Fn->INT32_MIN() + 1) {
      return 0;
    }
    unless ($simple->{long_value} == Fn->INT64_MIN() + 1) {
      return 0;
    }
    unless ($value_long2 == Fn->INT64_MIN() + 1) {
      return 0;
    }
    unless ($simple->{float_value} == Fn->FLT_MIN() + 1) {
      return 0;
    }
    unless ($value_float2 == Fn->FLT_MIN() + 1) {
      return 0;
    }
    unless ($simple->{double_value} == Fn->DBL_MIN() + 1) {
      return 0;
    }
    unless ($value_double2 = Fn->DBL_MIN() + 1) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_add_element_access_var_index : int () {
    my $values_byte = new byte[1];
    my $values_short = new short[1];
    my $values_int = new int[1];
    my $values_long = new long[1];
    my $values_float = new float[1];
    my $values_double = new double[1];
    
    $values_byte->[0] = Fn->INT8_MIN();
    $values_short->[0] = Fn->INT16_MIN();
    $values_int->[0] = Fn->INT32_MIN();
    $values_long->[0] = Fn->INT64_MIN();
    $values_float->[0] = Fn->FLT_MIN();
    $values_double->[0] = Fn->DBL_MIN();

    my $index = 0;
    my $value_byte2 = $values_byte->[$index] += 1;
    my $value_short2 = $values_short->[$index] += 1;
    my $value_int2 = $values_int->[$index] += 1;
    my $value_long2 = $values_long->[$index] += 1;
    my $value_float2 = $values_float->[$index] += 1;
    my $value_double2 = $values_double->[$index] += 1;
    
    unless ($values_byte->[0] == Fn->INT8_MIN() + 1) {
      return 0;
    }
    unless ($value_byte2 == Fn->INT8_MIN() + 1) {
      return 0;
    }
    unless ($values_short->[0] == Fn->INT16_MIN() + 1) {
      return 0;
    }
    unless ($value_short2 == Fn->INT16_MIN() + 1) {
      return 0;
    }
    unless ($values_int->[0] == Fn->INT32_MIN() + 1) {
      return 0;
    }
    unless ($value_int2 == Fn->INT32_MIN() + 1) {
      return 0;
    }
    unless ($values_long->[0] == Fn->INT64_MIN() + 1) {
      return 0;
    }
    unless ($value_long2 == Fn->INT64_MIN() + 1) {
      return 0;
    }
    unless ($values_float->[0] == Fn->FLT_MIN() + 1) {
      return 0;
    }
    unless ($value_float2 == Fn->FLT_MIN() + 1) {
      return 0;
    }
    unless ($values_double->[0] == Fn->DBL_MIN() + 1) {
      return 0;
    }
    unless ($value_double2 = Fn->DBL_MIN() + 1) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_add_element_access_constant_index : int () {
    my $values_byte = new byte[1];
    my $values_short = new short[1];
    my $values_int = new int[1];
    my $values_long = new long[1];
    my $values_float = new float[1];
    my $values_double = new double[1];
    
    $values_byte->[0] = Fn->INT8_MIN();
    $values_short->[0] = Fn->INT16_MIN();
    $values_int->[0] = Fn->INT32_MIN();
    $values_long->[0] = Fn->INT64_MIN();
    $values_float->[0] = Fn->FLT_MIN();
    $values_double->[0] = Fn->DBL_MIN();

    my $value_byte2 = $values_byte->[0] += 1;
    my $value_short2 = $values_short->[0] += 1;
    my $value_int2 = $values_int->[0] += 1;
    my $value_long2 = $values_long->[0] += 1;
    my $value_float2 = $values_float->[0] += 1;
    my $value_double2 = $values_double->[0] += 1;
    
    unless ($values_byte->[0] == Fn->INT8_MIN() + 1) {
      return 0;
    }
    unless ($value_byte2 == Fn->INT8_MIN() + 1) {
      return 0;
    }
    unless ($values_short->[0] == Fn->INT16_MIN() + 1) {
      return 0;
    }
    unless ($value_short2 == Fn->INT16_MIN() + 1) {
      return 0;
    }
    unless ($values_int->[0] == Fn->INT32_MIN() + 1) {
      return 0;
    }
    unless ($value_int2 == Fn->INT32_MIN() + 1) {
      return 0;
    }
    unless ($values_long->[0] == Fn->INT64_MIN() + 1) {
      return 0;
    }
    unless ($value_long2 == Fn->INT64_MIN() + 1) {
      return 0;
    }
    unless ($values_float->[0] == Fn->FLT_MIN() + 1) {
      return 0;
    }
    unless ($value_float2 == Fn->FLT_MIN() + 1) {
      return 0;
    }
    unless ($values_double->[0] == Fn->DBL_MIN() + 1) {
      return 0;
    }
    unless ($value_double2 = Fn->DBL_MIN() + 1) {
      return 0;
    }
    
    return 1;
  }

  static method special_assign_add_var : int () {
    my $value_byte = Fn->INT8_MIN();
    my $value_short = Fn->INT16_MIN();
    my $value_int = Fn->INT32_MIN();
    my $value_long = Fn->INT64_MIN();
    my $value_float = Fn->FLT_MIN();
    my $value_double = Fn->DBL_MIN();
    
    my $value_byte2 : byte = $value_byte += 1;
    my $value_short2 : short = $value_short += 1;
    my $value_int2 : int = $value_int += 1;
    my $value_long2 : long = $value_long += 1;
    my $value_float2 : float = $value_float += 1;
    my $value_double2 : double= $value_double += 1;
    
    unless ($value_byte == Fn->INT8_MIN() + 1) {
      return 0;
    }
    unless ($value_byte2 == Fn->INT8_MIN() + 1) {
      return 0;
    }
    unless ($value_short == Fn->INT16_MIN() + 1) {
      return 0;
    }
    unless ($value_short2 == Fn->INT16_MIN() + 1) {
      return 0;
    }
    unless ($value_int == Fn->INT32_MIN() + 1) {
      return 0;
    }
    unless ($value_int2 == Fn->INT32_MIN() + 1) {
      return 0;
    }
    unless ($value_long == Fn->INT64_MIN() + 1) {
      return 0;
    }
    unless ($value_long2 == Fn->INT64_MIN() + 1) {
      return 0;
    }
    unless ($value_float == Fn->FLT_MIN() + 1) {
      return 0;
    }
    unless ($value_float2 == Fn->FLT_MIN() + 1) {
      return 0;
    }
    unless ($value_double == Fn->DBL_MIN() + 1) {
      return 0;
    }
    unless ($value_double2 = Fn->DBL_MIN() + 1) {
      return 0;
    }
    
    return 1;
  }
  
  # Concat
  static method special_assign_concat : string () {
    
    {
      my $value = "a";
      
      $value .= "b";
      
      unless ($value isa string) {
        return 0;
      }
      unless ($value eq "ab") {
        return 0;
      }
    }

    {
      my $value = "a";
      
      $value .= (byte[])"b";
      
      unless ($value isa string) {
        return 0;
      }
      unless ($value eq "ab") {
        return 0;
      }
    }
    
    return 1;
  }
  
  static method special_assign : int () {
    my $num1 = 1;
    $num1 += 4;
    if ($num1 == 5) {
      return 0;
    }
    my $num2 = 5;
    $num2 -= 2;
    if ($num2 == 3) {
      return 0;
    }
    my $num3 = 3;
    $num3 *= 4;
    if ($num3 == 12) {
      return 0;
    }
    
    my $num4 = 6;
    $num4 /= 2;
    if ($num4 == 3) {
    }
    my $num5 = 10;
    $num5 %= 4;
    if ($num5 == 2) {
      return 0;
    }
    my $num6 = 8;
    $num6 <<= 1;
    if ($num6 == 16) {
      return 0;
    }
    my $num7 = -8;
    $num7 >>= 1;
    if ($num7 == -4) {
      return 0;
    }
    my $num8 = 0xFFFFFFFF;
    $num8 >>>= 1;
    if ($num8 == 0x7FFFFFFF) {
      return 0;
    }
    my $num9 = 0xFFFFFF00;
    $num9 &= 0xFF;
    if ($num9 == 0) {
      return 0;
    }
    my $num10 = 0xFFFFFF00;
    $num10 |= 0xFF;
    if ($num10 == 0xFFFFFFFF) {
      return 0;
    }
    my $num11 = 0xFFFFFF00;
    $num11 ^= 0xFFFF;
    if ($num11 == 0xFFFF00FF) {
      return 0;
    }
    
    return 1;
  }
  
  static method special_assign_defined_or : int () {
    
    {
      my $object = (Point)undef;
      
      $object //= Point->new;
      
      unless ($object is_type Point) {
        return 0;
      }
    }
    
    {
      my $simple = TestCase::Simple->new;
      
      $simple->{string_value} //= "foo";
      
      unless ($simple->{string_value} eq "foo") {
        return 0;
      }
      
    }
    
    return 1;
  }
  
}
