class TestCase::Module::Native::MethodCall {
  use Native::MethodCall;
  use Fn;
  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 Point;
  use Native;
  
  our $CALL_CALLBACK_VALUE : rw int;
  our $CALL_CLASS_METHOD_VALUE : rw int;
  
  static method new_class_method : int () {
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_byte");
      
      {
        my $ret = $class_method_call->call([(object)Fn->BYTE_MIN, (byte)1]);
        
        unless ($ret is_type Byte) {
          return 0;
        }
        
        unless ((byte)$ret == Fn->BYTE_MIN + 1) {
          return 0;
        }
      }
    }
    
    return 1;
  }
  
  static method new_instance_method_static : int () {
    
    {
      {
        my $point = Point->new(1, 2);
        
        my $instance_method_call = Native::MethodCall->new_instance_method_static("Point", "clear");
        
        $instance_method_call->call([(object)$point]);
        
        unless ($point->x == 0) {
          return 0;
        }
        
        unless ($point->y == 0) {
          return 0;
        }
        
      }
    }
    
    return 1;
  }
  
  static method call_instance_method_static : int () {
    
    {
      {
        my $point = Point->new(1, 2);
        
        Native::MethodCall->call_instance_method_static("Point", "clear", [(object)$point]);
        
        unless ($point->x == 0) {
          return 0;
        }
        
        unless ($point->y == 0) {
          return 0;
        }
        
      }
    }
    
    return 1;
  }
  
  static method new_instance_method : int () {
    
    {
      {
        my $point = Point->new(1, 2);
        
        my $instance_method_call = Native::MethodCall->new_instance_method($point, "clear");
        
        $instance_method_call->call([(object)$point]);
        
        unless ($point->x == 0) {
          return 0;
        }
        
        unless ($point->y == 0) {
          return 0;
        }
        
      }
    }
    
    return 1;
  }
  
  static method call_instance_method : int () {
    
    {
      {
        my $point = Point->new(1, 2);
        
        Native::MethodCall->call_instance_method("clear", [$point]);
        
        unless ($point->x == 0) {
          return 0;
        }
        
        unless ($point->y == 0) {
          return 0;
        }
        
      }
    }
    
    {
      my $error_id_ref = [-1];
      Native::MethodCall->call_instance_method(
        "",
        [
          (object)
          method : void () {
            TestCase::Module::Native::MethodCall->SET_CALL_CALLBACK_VALUE(1);
          },
        ],
        $error_id_ref,
      );
      
      unless ($error_id_ref->[0] == 0) {
        return 0;
      }
      
      unless ($CALL_CALLBACK_VALUE == 1) {
        return 0;
      }
      
      TestCase::Module::Native::MethodCall->SET_CALL_CALLBACK_VALUE(0);
    }
    
    {
      my $current_env = Native->get_current_env;
      
      my $stack = $current_env->new_stack;
      
      $@ = "Current Stack Error";
      
      my $error_id_ref = [-1];
      my $callback = method : void () {
        TestCase::Module::Native::MethodCall->SET_CALL_CALLBACK_VALUE(1);
      };
      my $args = [(object)$callback];
      
      Native::MethodCall->new_instance_method_with_env_stack(
        undef,
        $stack,
        $callback,
        "",
      )->call($args, $error_id_ref);
      
      unless ($error_id_ref->[0] == 0) {
        return 0;
      }
      
      unless ($CALL_CALLBACK_VALUE == 1) {
        return 0;
      }
      
      unless ($@ eq "Current Stack Error") {
        return 0;
      }
      
      $@ = undef;
      
      TestCase::Module::Native::MethodCall->SET_CALL_CALLBACK_VALUE(0);
    }
    
    {
      my $current_env = Native->get_current_env;
      
      my $stack = $current_env->new_stack;
      
      $@ = "Current Stack Error";
      
      my $error_id_ref = [-1];
      my $callback = [has value : int = 2] method : void () {
        TestCase::Module::Native::MethodCall->SET_CALL_CALLBACK_VALUE($self->{value});
      };
      my $args = [(object)$callback];
      my $instance_method_call = Native::MethodCall->new_instance_method_with_env_stack(
        undef,
        $stack,
        $callback,
        "",
      );
      $instance_method_call->call($args, $error_id_ref);
      
      unless ($error_id_ref->[0] == 0) {
        return 0;
      }
      
      unless ($CALL_CALLBACK_VALUE == 2) {
        return 0;
      }
      
      unless ($@ eq "Current Stack Error") {
        return 0;
      }
      
      $@ = undef;
      
      TestCase::Module::Native::MethodCall->SET_CALL_CALLBACK_VALUE(0);
    }
    
    # Exceptions
    {
      my $current_env = Native->get_current_env;
      
      my $stack = $current_env->new_stack;
      
      $@ = "Current Stack Error";
      
      my $error_id_ref = [-1];
      my $callback = method : void () {
        die "Call Back Error";
        TestCase::Module::Native::MethodCall->SET_CALL_CALLBACK_VALUE(1);
      };
      my $args = [(object)$callback];
      my $instance_method_call = Native::MethodCall->new_instance_method_with_env_stack(
        undef,
        $stack,
        $callback,
        "",
      );
      eval { $instance_method_call->call($args, $error_id_ref); }
      
      unless (eval_error_id isa_error Native::MethodCall::Error::ExceptionThrown) {
        return 0;
      }
      
      unless ($error_id_ref->[0] == basic_type_id Error) {
        return 0;
      }
      
      unless ($CALL_CALLBACK_VALUE == 0) {
        return 0;
      }
      
      unless (Fn->contains($@, "Call Back Error")) {
        return 0;
      }
      
      my $stack_exception = $instance_method_call->get_exception;
      
      unless (Fn->contains($stack_exception, "Call Back Error")) {
        return 0;
      }
      
      $instance_method_call->set_exception(undef);
      
      if ($instance_method_call->get_exception) {
        return 0;
      }
      
      $@ = undef;
    }
    
    return 1;
  }
  
  static method call : int () {
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_byte");
      
      {
        my $ret = $class_method_call->call([(object)Fn->BYTE_MIN, (byte)1]);
        
        unless ($ret is_type Byte) {
          return 0;
        }
        
        unless ((byte)$ret == Fn->BYTE_MIN + 1) {
          return 0;
        }
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_short");
      
      {
        my $ret = $class_method_call->call([(object)Fn->SHORT_MIN, (short)1]);
        
        unless ($ret is_type Short) {
          return 0;
        }
        
        unless ((short)$ret ==Fn->SHORT_MIN + 1) {
          return 0;
        }
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_int");
      
      {
        my $ret = $class_method_call->call([(object)(int)Fn->INT_MIN, (int)1]);
        
        unless ($ret is_type Int) {
          return 0;
        }
        
        unless ((int)$ret == Fn->INT_MIN + 1) {
          return 0;
        }
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_long");
      
      {
        my $ret = $class_method_call->call([(object)(long)Fn->LONG_MIN, (long)1]);
        
        unless ($ret is_type Long) {
          return 0;
        }
        
        unless ((long)$ret == Fn->LONG_MIN + 1) {
          return 0;
        }
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_float");
      
      {
        my $ret = $class_method_call->call([(object)(float)Fn->FLOAT_MIN, (float)1]);
        
        unless ($ret is_type Float) {
          return 0;
        }
        
        unless ((float)$ret == Fn->FLOAT_MIN + 1) {
          return 0;
        }
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_double");
      
      {
        my $ret = $class_method_call->call([(object)(double)Fn->DOUBLE_MIN, (double)1]);
        
        unless ($ret is_type Double) {
          return 0;
        }
        
        unless ((double)$ret == Fn->DOUBLE_MIN + 1) {
          return 0;
        }
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_mulnum_byte");
      
      {
        my $ret = (byte[])$class_method_call->call([(object)[Fn->BYTE_MIN, 2, 3], [(byte)1, 4, 5]]);
        
        unless ($ret is_type byte[]) {
          return 0;
        }
        
        unless ($ret->[0] == Fn->BYTE_MIN + 1) {
          return 0;
        }
        
        unless ($ret->[1] == 6) {
          return 0;
        }
        
        unless ($ret->[2] == 8) {
          return 0;
        }
        
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_mulnum_short");
      
      {
        my $ret = (short[])$class_method_call->call([(object)[Fn->SHORT_MIN, 2, 3], [(short)1, 4, 5]]);
        
        unless ($ret is_type short[]) {
          return 0;
        }
        
        unless ($ret->[0] == Fn->SHORT_MIN + 1) {
          return 0;
        }
        
        unless ($ret->[1] == 6) {
          return 0;
        }
        
        unless ($ret->[2] == 8) {
          return 0;
        }
        
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_mulnum_int");
      
      {
        my $ret = (int[])$class_method_call->call([(object)[(int)Fn->INT_MIN, 2, 3], [(int)1, 4, 5]]);
        
        unless ($ret is_type int[]) {
          return 0;
        }
        
        unless ($ret->[0] == Fn->INT_MIN + 1) {
          return 0;
        }
        
        unless ($ret->[1] == 6) {
          return 0;
        }
        
        unless ($ret->[2] == 8) {
          return 0;
        }
        
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_mulnum_long");
      
      {
        my $ret = (long[])$class_method_call->call([(object)[(long)Fn->LONG_MIN, 2, 3], [(long)1, 4, 5]]);
        
        unless ($ret is_type long[]) {
          return 0;
        }
        
        unless ($ret->[0] == Fn->LONG_MIN + 1) {
          return 0;
        }
        
        unless ($ret->[1] == 6) {
          return 0;
        }
        
        unless ($ret->[2] == 8) {
          return 0;
        }
        
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_mulnum_float");
      
      {
        my $ret = (float[])$class_method_call->call([(object)[(float)Fn->FLOAT_MIN, 2, 3], [(float)1, 4, 5]]);
        
        unless ($ret is_type float[]) {
          return 0;
        }
        
        unless ($ret->[0] == Fn->FLOAT_MIN + 1) {
          return 0;
        }
        
        unless ($ret->[1] == 6) {
          return 0;
        }
        
        unless ($ret->[2] == 8) {
          return 0;
        }
        
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_mulnum_double");
      
      {
        my $ret = (double[])$class_method_call->call([(object)[(double)Fn->DOUBLE_MIN, 2, 3], [(double)1, 4, 5]]);
        
        unless ($ret is_type double[]) {
          return 0;
        }
        
        unless ($ret->[0] == Fn->DOUBLE_MIN + 1) {
          return 0;
        }
        
        unless ($ret->[1] == 6) {
          return 0;
        }
        
        unless ($ret->[2] == 8) {
          return 0;
        }
        
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_byte_ref");
      
      {
        my $out = new byte[1];
        (byte[])$class_method_call->call([(object)Fn->BYTE_MIN, (byte)1, $out]);
        
        unless ($out->[0] == Fn->BYTE_MIN + 1) {
          return 0;
        }
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_short_ref");
      
      {
        my $out = new short[1];
        (short[])$class_method_call->call([(object)Fn->SHORT_MIN, (short)1, $out]);
        
        unless ($out->[0] == Fn->SHORT_MIN + 1) {
          return 0;
        }
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_int_ref");
      
      {
        my $out = new int[1];
        (int[])$class_method_call->call([(object)(int)Fn->INT_MIN, (int)1, $out]);
        
        unless ($out->[0] == Fn->INT_MIN + 1) {
          return 0;
        }
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_long_ref");
      
      {
        my $out = new long[1];
        (long[])$class_method_call->call([(object)(long)Fn->LONG_MIN, (long)1, $out]);
        
        unless ($out->[0] == Fn->LONG_MIN + 1) {
          return 0;
        }
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_float_ref");
      
      {
        my $out = new float[1];
        (float[])$class_method_call->call([(object)(float)Fn->FLOAT_MIN, (float)1, $out]);
        
        unless ($out->[0] == Fn->FLOAT_MIN + 1) {
          return 0;
        }
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_double_ref");
      
      {
        my $out = new double[1];
        (double[])$class_method_call->call([(object)(double)Fn->DOUBLE_MIN, (double)1, $out]);
        
        unless ($out->[0] == Fn->DOUBLE_MIN + 1) {
          return 0;
        }
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_mulnum_byte_ref");
      
      {
        my $out = new byte[3];
        $class_method_call->call([(object)[Fn->BYTE_MIN, 2, 3], [(byte)1, 4, 5], $out]);
        
        unless ($out->[0] == Fn->BYTE_MIN + 1) {
          return 0;
        }
        
        unless ($out->[1] == 6) {
          return 0;
        }
        
        unless ($out->[2] == 8) {
          return 0;
        }
        
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_mulnum_short_ref");
      
      {
        my $out = new short[3];
        $class_method_call->call([(object)[Fn->SHORT_MIN, 2, 3], [(short)1, 4, 5], $out]);
        
        unless ($out->[0] == Fn->SHORT_MIN + 1) {
          return 0;
        }
        
        unless ($out->[1] == 6) {
          return 0;
        }
        
        unless ($out->[2] == 8) {
          return 0;
        }
        
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_mulnum_int_ref");
      
      {
        my $out = new int[3];
        $class_method_call->call([(object)[(int)Fn->INT_MIN, 2, 3], [(int)1, 4, 5], $out]);
        
        unless ($out->[0] == Fn->INT_MIN + 1) {
          return 0;
        }
        
        unless ($out->[1] == 6) {
          return 0;
        }
        
        unless ($out->[2] == 8) {
          return 0;
        }
        
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_mulnum_long_ref");
      
      {
        my $out = new long[3];
        $class_method_call->call([(object)[(long)Fn->LONG_MIN, 2, 3], [(long)1, 4, 5], $out]);
        
        unless ($out->[0] == Fn->LONG_MIN + 1) {
          return 0;
        }
        
        unless ($out->[1] == 6) {
          return 0;
        }
        
        unless ($out->[2] == 8) {
          return 0;
        }
        
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_mulnum_float_ref");
      
      {
        my $out = new float[3];
        $class_method_call->call([(object)[(float)Fn->FLOAT_MIN, 2, 3], [(float)1, 4, 5], $out]);
        
        unless ($out->[0] == Fn->FLOAT_MIN + 1) {
          return 0;
        }
        
        unless ($out->[1] == 6) {
          return 0;
        }
        
        unless ($out->[2] == 8) {
          return 0;
        }
        
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_mulnum_double_ref");
      
      {
        my $out = new double[3];
        $class_method_call->call([(object)[(double)Fn->DOUBLE_MIN, 2, 3], [(double)1, 4, 5], $out]);
        
        unless ($out->[0] == Fn->DOUBLE_MIN + 1) {
          return 0;
        }
        
        unless ($out->[1] == 6) {
          return 0;
        }
        
        unless ($out->[2] == 8) {
          return 0;
        }
        
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_point");
      
      {
        my $ret = (Point)$class_method_call->call([(object)Point->new(Fn->INT_MIN, 2), Point->new(1, 4)]);
        
        unless ($ret is_type Point) {
          return 0;
        }
        
        unless ($ret->x == Fn->INT_MIN + 1) {
          return 0;
        }
        
        unless ($ret->y == 6) {
          return 0;
        }
        
      }
    }
    
    {
      my $class_method_call = Native::MethodCall->new_class_method("Point", "new");
      
      {
        my $point = (Point)$class_method_call->call([(object)1, 2]);
        
        unless ($point is_type Point) {
          return 0;
        }
        
        unless ($point->x == 1) {
          return 0;
        }
        
        unless ($point->y == 2) {
          return 0;
        }
        
      }
    }
    
    # Exceptions
    {
      {
        my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_byte");
        
        {
          eval { $class_method_call->call([(object)Fn->BYTE_MIN]); }
          
          unless (Fn->contains($@, "TestCase::Module::Native::MethodCall#add_byte method")) {
            diag;
            return 0;
          }
        }
      }
      
      {
        my $class_method_call = Native::MethodCall->new_class_method("TestCase::Module::Native::MethodCall", "add_byte");
        
        {
          eval { $class_method_call->call([(object)Fn->BYTE_MIN, 1, 2]); }
          
          unless (Fn->contains($@, "TestCase::Module::Native::MethodCall#add_byte method")) {
            diag $@;
            return 0;
          }
        }
      }
    }
    
    return 1;
  }
  
  static method one : int () {
    
    return 1;
  }
  
  static method add_byte : byte ($arg0 : byte, $arg1 : byte) {
    
    my $ret = (byte)($arg0 + $arg1);
    
    return $ret;
  }
  
  static method add_short : short ($arg0 : short, $arg1 : short) {
    
    my $ret = (short)($arg0 + $arg1);
    
    return $ret;
  }
  
  static method add_int : int ($arg0 : int, $arg1 : int) {
    
    my $ret = (int)($arg0 + $arg1);
    
    return $ret;
  }
  
  static method add_long : long ($arg0 : long, $arg1 : long) {
    
    my $ret = (long)($arg0 + $arg1);
    
    return $ret;
  }
  
  static method add_float : float ($arg0 : float, $arg1 : float) {
    
    my $ret = (float)($arg0 + $arg1);
    
    return $ret;
  }
  
  static method add_double : double ($arg0 : double, $arg1 : double) {
    
    my $ret = (double)($arg0 + $arg1);
    
    return $ret;
  }
  
  static method add_mulnum_byte : TestCase::Point_3b ($arg0 : TestCase::Point_3b, $arg1 : TestCase::Point_3b) {
    
    my $ret : TestCase::Point_3b;
    $ret->{x} = (byte)($arg0->{x} + $arg1->{x});
    $ret->{y} = (byte)($arg0->{y} + $arg1->{y});
    $ret->{z} = (byte)($arg0->{z} + $arg1->{z});
    
    return $ret;
  }
  
  static method add_mulnum_short : TestCase::Point_3s ($arg0 : TestCase::Point_3s, $arg1 : TestCase::Point_3s) {
    
    my $ret : TestCase::Point_3s;
    $ret->{x} = (short)($arg0->{x} + $arg1->{x});
    $ret->{y} = (short)($arg0->{y} + $arg1->{y});
    $ret->{z} = (short)($arg0->{z} + $arg1->{z});
    
    return $ret;
  }
  
  static method add_mulnum_int : TestCase::Point_3i ($arg0 : TestCase::Point_3i, $arg1 : TestCase::Point_3i) {
    
    my $ret : TestCase::Point_3i;
    $ret->{x} = (int)($arg0->{x} + $arg1->{x});
    $ret->{y} = (int)($arg0->{y} + $arg1->{y});
    $ret->{z} = (int)($arg0->{z} + $arg1->{z});
    
    return $ret;
  }
  
  static method add_mulnum_long : TestCase::Point_3l ($arg0 : TestCase::Point_3l, $arg1 : TestCase::Point_3l) {
    
    my $ret : TestCase::Point_3l;
    $ret->{x} = (long)($arg0->{x} + $arg1->{x});
    $ret->{y} = (long)($arg0->{y} + $arg1->{y});
    $ret->{z} = (long)($arg0->{z} + $arg1->{z});
    
    return $ret;
  }
  
  static method add_mulnum_float : TestCase::Point_3f ($arg0 : TestCase::Point_3f, $arg1 : TestCase::Point_3f) {
    
    my $ret : TestCase::Point_3f;
    $ret->{x} = (float)($arg0->{x} + $arg1->{x});
    $ret->{y} = (float)($arg0->{y} + $arg1->{y});
    $ret->{z} = (float)($arg0->{z} + $arg1->{z});
    
    return $ret;
  }
  
  static method add_mulnum_double : TestCase::Point_3d ($arg0 : TestCase::Point_3d, $arg1 : TestCase::Point_3d) {
    
    my $ret : TestCase::Point_3d;
    $ret->{x} = (double)($arg0->{x} + $arg1->{x});
    $ret->{y} = (double)($arg0->{y} + $arg1->{y});
    $ret->{z} = (double)($arg0->{z} + $arg1->{z});
    
    return $ret;
  }
  
  static method add_byte_ref : void ($arg0 : byte, $arg1 : byte, $arg_out : byte*) {
    
    $$arg_out = (byte)($arg0 + $arg1);
  }
  
  static method add_short_ref : void ($arg0 : short, $arg1 : short, $arg_out : short*) {
    
    $$arg_out = (short)($arg0 + $arg1);
  }
  
  static method add_int_ref : void ($arg0 : int, $arg1 : int, $arg_out : int*) {
    
    $$arg_out = (int)($arg0 + $arg1);
  }
  
  static method add_long_ref : void ($arg0 : long, $arg1 : long, $arg_out : long*) {
    
    $$arg_out = (long)($arg0 + $arg1);
  }
  
  static method add_float_ref : void ($arg0 : float, $arg1 : float, $arg_out : float*) {
    
    $$arg_out = (float)($arg0 + $arg1);
  }
  
  static method add_double_ref : void ($arg0 : double, $arg1 : double, $arg_out : double*) {
    
    $$arg_out = (double)($arg0 + $arg1);
  }
  
  static method add_mulnum_byte_ref : void ($arg0 : TestCase::Point_3b, $arg1 : TestCase::Point_3b, $out : TestCase::Point_3b*) {
    
    $out->{x} = (byte)($arg0->{x} + $arg1->{x});
    $out->{y} = (byte)($arg0->{y} + $arg1->{y});
    $out->{z} = (byte)($arg0->{z} + $arg1->{z});
  }
  
  static method add_mulnum_short_ref : void ($arg0 : TestCase::Point_3s, $arg1 : TestCase::Point_3s, $out : TestCase::Point_3s*) {
    
    $out->{x} = (short)($arg0->{x} + $arg1->{x});
    $out->{y} = (short)($arg0->{y} + $arg1->{y});
    $out->{z} = (short)($arg0->{z} + $arg1->{z});
  }
  
  static method add_mulnum_int_ref : void ($arg0 : TestCase::Point_3i, $arg1 : TestCase::Point_3i, $out : TestCase::Point_3i*) {
    
    $out->{x} = (int)($arg0->{x} + $arg1->{x});
    $out->{y} = (int)($arg0->{y} + $arg1->{y});
    $out->{z} = (int)($arg0->{z} + $arg1->{z});
  }
  
  static method add_mulnum_long_ref : void ($arg0 : TestCase::Point_3l, $arg1 : TestCase::Point_3l, $out : TestCase::Point_3l*) {
    
    $out->{x} = (long)($arg0->{x} + $arg1->{x});
    $out->{y} = (long)($arg0->{y} + $arg1->{y});
    $out->{z} = (long)($arg0->{z} + $arg1->{z});
  }
  
  static method add_mulnum_float_ref : void ($arg0 : TestCase::Point_3f, $arg1 : TestCase::Point_3f, $out : TestCase::Point_3f*) {
    
    $out->{x} = (float)($arg0->{x} + $arg1->{x});
    $out->{y} = (float)($arg0->{y} + $arg1->{y});
    $out->{z} = (float)($arg0->{z} + $arg1->{z});
  }
  
  static method add_mulnum_double_ref : void ($arg0 : TestCase::Point_3d, $arg1 : TestCase::Point_3d, $out : TestCase::Point_3d*) {
    
    $out->{x} = (double)($arg0->{x} + $arg1->{x});
    $out->{y} = (double)($arg0->{y} + $arg1->{y});
    $out->{z} = (double)($arg0->{z} + $arg1->{z});
  }
  
  static method add_point : Point ($arg0 : Point, $arg1 : Point) {
    
    my $x_total = $arg0->x + $arg1->x;
    
    my $y_total = $arg0->y + $arg1->y;
    
    my $ret = Point->new($x_total, $y_total);
    
    return $ret;
  }
  
  static method call_class_method_for_env : int () {
    
    return 1;
  }
  
  static method set_class_var : void () {
    $CALL_CLASS_METHOD_VALUE = 1;
  }
  
  static method call_class_method : int () {
    
    {
      my $ret = Native::MethodCall->call_class_method("TestCase::Module::Native::MethodCall", "add_byte", [(object)Fn->BYTE_MIN, (byte)1]);
      
      unless ($ret is_type Byte) {
        return 0;
      }
      
      unless ((byte)$ret == Fn->BYTE_MIN + 1) {
        return 0;
      }
    }
    
    {
      my $ret = Native::MethodCall->call_class_method("TestCase::Module::Native::MethodCall", "one");
      
      unless ((int)$ret == 1) {
        return 0;
      }
    }
    
    {
      TestCase::Module::Native::MethodCall->SET_CALL_CLASS_METHOD_VALUE(0);
      
      my $error_id_ref = [-1];
      Native::MethodCall->new_class_method_with_env_stack(undef, undef, "TestCase::Module::Native::MethodCall", "set_class_var")->call(undef, $error_id_ref);
      
      unless ($error_id_ref->[0] == 0) {
        return 0;
      }
      
      unless ($CALL_CLASS_METHOD_VALUE == 1) {
        return 0;
      }
    }
    
    {
      TestCase::Module::Native::MethodCall->SET_CALL_CLASS_METHOD_VALUE(0);
      my $error_id_ref = [-1];
      my $stack = Native->get_current_stack;
      Native::MethodCall->new_class_method_with_env_stack(undef, $stack, "TestCase::Module::Native::MethodCall", "set_class_var")->call(undef, $error_id_ref);
      
      unless ($error_id_ref->[0] == 0) {
        return 0;
      }
      
      unless ($CALL_CLASS_METHOD_VALUE == 1) {
        return 0;
      }
    }
    
    {
      TestCase::Module::Native::MethodCall->SET_CALL_CLASS_METHOD_VALUE(0);
      
      my $error_id_ref = [-1];
      my $stack = Native->get_current_stack;
      my $env = Native->get_current_env;
      Native::MethodCall->new_class_method_with_env_stack($env, $stack, "TestCase::Module::Native::MethodCall", "set_class_var")->call(undef, $error_id_ref);
      
      unless ($error_id_ref->[0] == 0) {
        return 0;
      }
      
      unless ($CALL_CLASS_METHOD_VALUE == 1) {
        return 0;
      }
      
      TestCase::Module::Native::MethodCall->SET_CALL_CLASS_METHOD_VALUE(0);
    }
    
    return 1;
  }
  
  static method new_proto : int () {
    
    {
      my $point = Point->new(1, 2);
      
      my $ret = (Point)Native::MethodCall->new_proto($point, [(object)2, 3]);
      
      unless ($ret is_type Point) {
        return 0;
      }
      
      unless ($ret->x == 2) {
        return 0;
      }
      
      unless ($ret->y == 3) {
        return 0;
      }
      
    }
    
    # Exceptions
    {
      eval { Native::MethodCall->new_proto(undef, [(object)2, 3]); }
      
      unless ($@) {
        return 0;
      }
    }
    
    $@ = undef;
    
    return 1;
  }
}
