class TestCase::R::NDArray::Long {
  
  use R::NDArray::Long;
  use R::OP::Int as IOP;
  
  static method data : int () {
    
    my $data = [(long)1, 2, 3];
    my $dim = [1, 3];
    my $ndarray = R::NDArray::Long->new({data => $data, dim => $dim});
    
    my $got_data = $ndarray->data;
    
    unless ($got_data is_compile_type long[]) {
      return 0;
    }
    
    unless ($got_data == $data) {
      return 0;
    }
    
    return 1;
  }
  
  static method new : int () {
    
    my $data = [(long)1, 2, 3];
    my $dim = [1, 3];
    my $ndarray = R::NDArray::Long->new({data => $data, dim => $dim});
    
    unless ($ndarray is_type R::NDArray::Long) {
      return 0;
    }
    
    unless ($ndarray->data == $data) {
      return 0;
    }
    
    unless (Array->equals_int($ndarray->dim, [1, 3])) {
      return 0;
    }
    
    return 1;
  }
  
  static method create_default_data : int () {
    
    {
      my $ndarray = R::NDArray::Long->new;
      
      my $default_data = $ndarray->create_default_data;
      
      unless ($default_data is_type long[]) {
        return 0;
      }
      
      unless (Array->equals_long($default_data, new long[0])) {
        return 0;
      }
    }
    
    {
      my $ndarray = R::NDArray::Long->new;
      
      my $length = 0;
      my $default_data = $ndarray->create_default_data($length);
      
      unless ($default_data is_type long[]) {
        return 0;
      }
      
      unless (Array->equals_long($default_data, new long[0])) {
        return 0;
      }
    }
    
    {
      my $ndarray = R::NDArray::Long->new;
      
      my $length = 2;
      my $default_data = $ndarray->create_default_data($length);
      
      unless ($default_data is_type long[]) {
        return 0;
      }
      
      unless (Array->equals_long($default_data, [(long)0, 0])) {
        return 0;
      }
    }
    
    return 1;
  }
  
  static method elem_to_string : int () {
    
    my $ndarray = R::NDArray::Long->new;
    
    my $data = [(long)1, 2];
    
    my $data_index = 1;
    
    my $string = $ndarray->elem_to_string($data, $data_index);
    
    unless ($string eq (string)$data->[$data_index]) {
      return 0;
    }
    
    return 1;
  }
  
  static method elem_assign : int () {
    
    my $ndarray = R::NDArray::Long->new;
    
    my $dist_data = [(long)0, 0];
    
    my $dist_data_index = 1;
    
    my $src_data = [(long)1, 2];
    
    my $src_data_index = 1;
    
    $ndarray->elem_assign($dist_data, $dist_data_index, $src_data, $src_data_index);
    
    unless ($dist_data->[$dist_data_index] == $src_data->[$src_data_index]) {
      return 0;
    }
    
    return 1;
  }
  
  static method elem_clone : int () {
    
    my $ndarray = R::NDArray::Long->new;
    
    my $dist_data = [(long)0, 0];
    
    my $dist_data_index = 1;
    
    my $src_data = [(long)1, 2];
    
    my $src_data_index = 1;
    
    $ndarray->elem_clone($dist_data, $dist_data_index, $src_data, $src_data_index);
    
    unless ($dist_data->[$dist_data_index] == $src_data->[$src_data_index]) {
      return 0;
    }
    
    return 1;
  }
  
  static method elem_cmp : int () {
    
    my $ndarray = R::NDArray::Long->new;
    
    my $data = [(long)1, 2];
    
    my $a_data_index = 0;
    
    my $b_data_index = 1;
    
    my $ret_cmp = $ndarray->elem_cmp($data, $a_data_index, $data, $b_data_index);
    
    unless ($ret_cmp == ($data->[$a_data_index] <=> $data->[$b_data_index])) {
      return 0;
    }
    
    return 1;
  }
  
  static method clone : int () {
    
    {
      my $data = [(long)1, 2, 3];
      my $dim = [1, 3];
      my $ndarray = R::NDArray::Long->new({data => $data, dim => $dim});
      
      my $ret_ndarray = $ndarray->clone;
      
      unless ($ret_ndarray is_type R::NDArray::Long) {
        return 0;
      }
      
      if ($ret_ndarray->data == $ndarray->data) {
        return 0;
      }
      
      unless (Array->equals_long($ret_ndarray->data, $ndarray->data)) {
        return 0;
      }
      
      unless (Array->equals_int($ret_ndarray->dim, [1, 3])) {
        return 0;
      }
    }
    
    {
      my $data = [(long)1, 2, 3];
      my $dim = [1, 3];
      my $ndarray = R::NDArray::Long->new({data => $data, dim => $dim});
      
      my $shallow = 1;
      my $ret_ndarray = $ndarray->clone($shallow);
      
      unless ($ret_ndarray is_type R::NDArray::Long) {
        return 0;
      }
      
      if ($ret_ndarray->data == $ndarray->data) {
        return 0;
      }
      
      unless (Array->equals_long($ret_ndarray->data, $ndarray->data)) {
        return 0;
      }
      
      unless (Array->equals_int($ret_ndarray->dim, [1, 3])) {
        return 0;
      }
    }
    
    return 1;
  }
  
  static method slice : int () {
    
    {
      my $data = [(long)1, 2, 3, 4, 5, 6];
      my $dim = [2, 3];
      my $ndarray = R::NDArray::Long->new({data => $data, dim => $dim});
      
      my $asix_indexes_product = [IOP->c([0, 1]), IOP->c([1])];
      my $ret_ndarray = $ndarray->slice($asix_indexes_product);
      
      unless ($ret_ndarray is_type R::NDArray::Long) {
        return 0;
      }
      
      unless (Array->equals_long($ret_ndarray->data, [(long)3, 4])) {
        return 0;
      }
      
      unless (Array->equals_int($ret_ndarray->dim, [2, 1])) {
        return 0;
      }
    }
    
    return 1;
  }
  
  static method to_int_ndarray : int () {
    
    {
      my $data = [(long)1, 2, 3];
      my $dim = [1, 3];
      my $ndarray = R::NDArray::Long->new({data => $data, dim => $dim});
      
      my $ret_ndarray = $ndarray->to_int_ndarray;
      
      unless ($ret_ndarray is_type R::NDArray::Int) {
        return 0;
      }
      
      if ($ret_ndarray->data == $ndarray->data) {
        return 0;
      }
      
      unless (Array->equals_int($ret_ndarray->data, [(int)1, 2, 3])) {
        return 0;
      }
      
      unless (Array->equals_int($ret_ndarray->dim, [1, 3])) {
        return 0;
      }
    }
    
    return 1;
  }
  
  static method to_float_ndarray : int () {
    
    {
      my $data = [(long)1, 2, 3];
      my $dim = [1, 3];
      my $ndarray = R::NDArray::Long->new({data => $data, dim => $dim});
      
      my $ret_ndarray = $ndarray->to_float_ndarray;
      
      unless ($ret_ndarray is_type R::NDArray::Float) {
        return 0;
      }
      
      if ($ret_ndarray->data == $ndarray->data) {
        return 0;
      }
      
      unless (Array->equals_float($ret_ndarray->data, [(float)1f, 2f, 3f])) {
        return 0;
      }
      
      unless (Array->equals_int($ret_ndarray->dim, [1, 3])) {
        return 0;
      }
    }
    
    return 1;
  }
  
  static method to_double_ndarray : int () {
    
    {
      my $data = [(long)1, 2, 3];
      my $dim = [1, 3];
      my $ndarray = R::NDArray::Long->new({data => $data, dim => $dim});
      
      my $ret_ndarray = $ndarray->to_double_ndarray;
      
      unless ($ret_ndarray is_type R::NDArray::Double) {
        return 0;
      }
      
      if ($ret_ndarray->data == $ndarray->data) {
        return 0;
      }
      
      unless (Array->equals_double($ret_ndarray->data, [(double)1, 2, 3])) {
        return 0;
      }
      
      unless (Array->equals_int($ret_ndarray->dim, [1, 3])) {
        return 0;
      }
    }
    
    return 1;
  }
}