github.com/sbinet/go-cfitsio@v0.0.0-20140625105338-0307f985659e/file_test.go (about)

     1  package cfitsio
     2  
     3  import (
     4  	"bytes"
     5  	"io/ioutil"
     6  	"os"
     7  	"strings"
     8  	"testing"
     9  )
    10  
    11  func TestOpenFile(t *testing.T) {
    12  	const fname = "testdata/file001.fits"
    13  	f, err := Open(fname, ReadOnly)
    14  	if err != nil {
    15  		t.Fatalf("could not open FITS file [%s]: %v", fname, err)
    16  	}
    17  	defer f.Close()
    18  
    19  	fmode, err := f.Mode()
    20  	if err != nil {
    21  		t.Fatalf("error mode: %v", err)
    22  	}
    23  	if fmode != ReadOnly {
    24  		t.Fatalf("expected file-mode [%v]. got [%v]", ReadOnly, fmode)
    25  	}
    26  
    27  	name, err := f.Name()
    28  	if err != nil {
    29  		t.Fatalf("error name: %v", err)
    30  	}
    31  	if name != fname {
    32  		t.Fatalf("expected file-name [%v]. got [%v]", fname, name)
    33  	}
    34  
    35  	furl, err := f.UrlType()
    36  	if err != nil {
    37  		t.Fatalf("error url: %v", err)
    38  	}
    39  	if furl != "file://" {
    40  		t.Fatalf("expected file-url [%v]. got [%v]", "file://", furl)
    41  	}
    42  
    43  }
    44  
    45  func TestAsciiTbl(t *testing.T) {
    46  	const fname = "testdata/file001.fits"
    47  	f, err := Open(fname, ReadOnly)
    48  	if err != nil {
    49  		t.Fatalf("could not open FITS file [%s]: %v", fname, err)
    50  	}
    51  	defer f.Close()
    52  
    53  	nhdus, err := f.NumHDUs()
    54  	if err != nil {
    55  		t.Fatalf("error hdu: %v", err)
    56  	}
    57  
    58  	if nhdus != 2 {
    59  		t.Fatalf("expected #hdus [%v]. got [%v]", 2, nhdus)
    60  	}
    61  
    62  	ihdu := f.HDUNum()
    63  	if ihdu != 0 {
    64  		t.Fatalf("expected hdu number [%v]. got [%v]", 0, ihdu)
    65  	}
    66  
    67  	hdutype, err := f.HDUType()
    68  	if err != nil {
    69  		t.Fatalf("error hdu-type: %v", err)
    70  	}
    71  	if hdutype != IMAGE_HDU {
    72  		t.Fatalf("expected hdu type [%v]. got [%v]", IMAGE_HDU, hdutype)
    73  	}
    74  
    75  	buf := bytes.NewBuffer(nil)
    76  	err = WriteHDU(buf, &f)
    77  	if err != nil {
    78  		t.Fatalf("error write-hdu: %v", err)
    79  	}
    80  	hdu_tmp := strings.Trim(string(buf.Bytes()), " ")
    81  	hdu_ref, err := ioutil.ReadFile("testdata/ref.file001.hdu")
    82  	if err != nil {
    83  		t.Fatalf("error reading ref file: %v", err)
    84  	}
    85  	if string(hdu_ref) != hdu_tmp {
    86  		t.Fatalf("expected hdu-write:\n%v\ngot:\n%v", string(hdu_ref), hdu_tmp)
    87  	}
    88  
    89  	// move to next header
    90  	err = f.SeekHDU(1, 1)
    91  	if err != nil {
    92  		t.Fatalf("error next-hdu: %v", err)
    93  	}
    94  
    95  	ihdu = f.HDUNum()
    96  	if ihdu != 1 {
    97  		t.Fatalf("expected hdu number [%v]. got [%v]", 1, ihdu)
    98  	}
    99  
   100  	hdutype, err = f.HDUType()
   101  	if err != nil {
   102  		t.Fatalf("error hdu-type: %v", err)
   103  	}
   104  	if hdutype != ASCII_TBL {
   105  		t.Fatalf("expected hdu type [%v]. got [%v]", ASCII_TBL, hdutype)
   106  	}
   107  
   108  	// move to first header
   109  	err = f.SeekHDU(0, 0)
   110  	if err != nil {
   111  		t.Fatalf("error abs-hdu: %v", err)
   112  	}
   113  
   114  	ihdu = f.HDUNum()
   115  	if ihdu != 0 {
   116  		t.Fatalf("expected hdu number [%v]. got [%v]", 0, ihdu)
   117  	}
   118  
   119  	hdutype, err = f.HDUType()
   120  	if err != nil {
   121  		t.Fatalf("error hdu-type: %v", err)
   122  	}
   123  	if hdutype != IMAGE_HDU {
   124  		t.Fatalf("expected hdu type [%v]. got [%v]", IMAGE_HDU, hdutype)
   125  	}
   126  
   127  	// move to second header
   128  	err = f.SeekHDU(1, 0)
   129  	if err != nil {
   130  		t.Fatalf("error abs-hdu: %v", err)
   131  	}
   132  
   133  	ihdu = f.HDUNum()
   134  	if ihdu != 1 {
   135  		t.Fatalf("expected hdu number [%v]. got [%v]", 1, ihdu)
   136  	}
   137  
   138  	hdutype, err = f.HDUType()
   139  	if err != nil {
   140  		t.Fatalf("error hdu-type: %v", err)
   141  	}
   142  	if hdutype != ASCII_TBL {
   143  		t.Fatalf("expected hdu type [%v]. got [%v]", ASCII_TBL, hdutype)
   144  	}
   145  
   146  	// move to non-existent header
   147  	err = f.SeekHDU(2, 0)
   148  	if err == nil {
   149  		t.Fatalf("expected error")
   150  	}
   151  	if err != END_OF_FILE {
   152  		t.Fatalf("expected error [%v]. got [%v]", END_OF_FILE, err)
   153  	}
   154  	ihdu = f.HDUNum()
   155  	if ihdu != 1 {
   156  		t.Fatalf("expected hdu number [%v]. got [%v]", 1, ihdu)
   157  	}
   158  
   159  	// move to non-existent header
   160  	err = f.SeekHDU(-1, 0)
   161  	if err == nil {
   162  		t.Fatalf("expected error")
   163  	}
   164  	if err != BAD_HDU_NUM {
   165  		t.Fatalf("expected error [%v]. got [%v]", BAD_HDU_NUM, err)
   166  	}
   167  	ihdu = f.HDUNum()
   168  	if ihdu != 1 {
   169  		t.Fatalf("expected hdu number [%v]. got [%v]", 1, ihdu)
   170  	}
   171  
   172  	// move to first header
   173  	err = f.SeekHDU(0, 0)
   174  	if err != nil {
   175  		t.Fatalf("error abs-hdu: %v", err)
   176  	}
   177  
   178  	ihdu = f.HDUNum()
   179  	if ihdu != 0 {
   180  		t.Fatalf("expected hdu number [%v]. got [%v]", 0, ihdu)
   181  	}
   182  
   183  	// move to hdu by name
   184  	err = f.SeekHDUByName(ASCII_TBL, "TABLE", 1)
   185  	if err != BAD_HDU_NUM {
   186  		t.Fatalf("expected error [%v]. got [%v]", BAD_HDU_NUM, err)
   187  	}
   188  }
   189  
   190  func TestBinTable(t *testing.T) {
   191  	const fname = "testdata/swp06542llg.fits"
   192  	f, err := Open(fname, ReadOnly)
   193  	if err != nil {
   194  		t.Fatalf("could not open FITS file [%s]: %v", fname, err)
   195  	}
   196  	defer f.Close()
   197  
   198  	nhdus, err := f.NumHDUs()
   199  	if err != nil {
   200  		t.Fatalf("error hdu: %v", err)
   201  	}
   202  
   203  	if nhdus != 2 {
   204  		t.Fatalf("expected #hdus [%v]. got [%v]", 2, nhdus)
   205  	}
   206  
   207  	ihdu := f.HDUNum()
   208  	if ihdu != 0 {
   209  		t.Fatalf("expected hdu number [%v]. got [%v]", 0, ihdu)
   210  	}
   211  
   212  	hdutype, err := f.HDUType()
   213  	if err != nil {
   214  		t.Fatalf("error hdu-type: %v", err)
   215  	}
   216  	if hdutype != IMAGE_HDU {
   217  		t.Fatalf("expected hdu type [%v]. got [%v]", IMAGE_HDU, hdutype)
   218  	}
   219  
   220  	buf := bytes.NewBuffer(nil)
   221  	err = WriteHDU(buf, &f)
   222  	if err != nil {
   223  		t.Fatalf("error write-hdu: %v", err)
   224  	}
   225  
   226  	hdu_tmp := strings.Trim(string(buf.Bytes()), " ")
   227  	hdu_ref, err := ioutil.ReadFile("testdata/ref.swp06542llg.hdu")
   228  	if err != nil {
   229  		t.Fatalf("error reading ref file: %v", err)
   230  	}
   231  	if string(hdu_ref) != hdu_tmp {
   232  		t.Fatalf("expected hdu-write:\n%v\ngot:\n%v", string(hdu_ref), hdu_tmp)
   233  	}
   234  
   235  	// move to next header
   236  	err = f.SeekHDU(1, 1)
   237  	if err != nil {
   238  		t.Fatalf("error next-hdu: %v", err)
   239  	}
   240  
   241  	ihdu = f.HDUNum()
   242  	if ihdu != 1 {
   243  		t.Fatalf("expected hdu number [%v]. got [%v]", 1, ihdu)
   244  	}
   245  
   246  	hdutype, err = f.HDUType()
   247  	if err != nil {
   248  		t.Fatalf("error hdu-type: %v", err)
   249  	}
   250  	if hdutype != BINARY_TBL {
   251  		t.Fatalf("expected hdu type [%v]. got [%v]", BINARY_TBL, hdutype)
   252  	}
   253  
   254  	// move to first header
   255  	err = f.SeekHDU(0, 0)
   256  	if err != nil {
   257  		t.Fatalf("error abs-hdu: %v", err)
   258  	}
   259  
   260  	ihdu = f.HDUNum()
   261  	if ihdu != 0 {
   262  		t.Fatalf("expected hdu number [%v]. got [%v]", 0, ihdu)
   263  	}
   264  
   265  	hdutype, err = f.HDUType()
   266  	if err != nil {
   267  		t.Fatalf("error hdu-type: %v", err)
   268  	}
   269  	if hdutype != IMAGE_HDU {
   270  		t.Fatalf("expected hdu type [%v]. got [%v]", IMAGE_HDU, hdutype)
   271  	}
   272  
   273  	// move to second header
   274  	err = f.SeekHDU(1, 0)
   275  	if err != nil {
   276  		t.Fatalf("error abs-hdu: %v", err)
   277  	}
   278  
   279  	ihdu = f.HDUNum()
   280  	if ihdu != 1 {
   281  		t.Fatalf("expected hdu number [%v]. got [%v]", 1, ihdu)
   282  	}
   283  
   284  	hdutype, err = f.HDUType()
   285  	if err != nil {
   286  		t.Fatalf("error hdu-type: %v", err)
   287  	}
   288  	if hdutype != BINARY_TBL {
   289  		t.Fatalf("expected hdu type [%v]. got [%v]", BINARY_TBL, hdutype)
   290  	}
   291  
   292  	// move to non-existent header
   293  	err = f.SeekHDU(2, 0)
   294  	if err == nil {
   295  		t.Fatalf("expected error")
   296  	}
   297  	if err != END_OF_FILE {
   298  		t.Fatalf("expected error [%v]. got [%v]", END_OF_FILE, err)
   299  	}
   300  	ihdu = f.HDUNum()
   301  	if ihdu != 1 {
   302  		t.Fatalf("expected hdu number [%v]. got [%v]", 1, ihdu)
   303  	}
   304  
   305  	// move to non-existent header
   306  	err = f.SeekHDU(-1, 0)
   307  	if err == nil {
   308  		t.Fatalf("expected error")
   309  	}
   310  	if err != BAD_HDU_NUM {
   311  		t.Fatalf("expected error [%v]. got [%v]", BAD_HDU_NUM, err)
   312  	}
   313  	ihdu = f.HDUNum()
   314  	if ihdu != 1 {
   315  		t.Fatalf("expected hdu number [%v]. got [%v]", 1, ihdu)
   316  	}
   317  
   318  	// move to first header
   319  	err = f.SeekHDU(0, 0)
   320  	if err != nil {
   321  		t.Fatalf("error abs-hdu: %v", err)
   322  	}
   323  
   324  	ihdu = f.HDUNum()
   325  	if ihdu != 0 {
   326  		t.Fatalf("expected hdu number [%v]. got [%v]", 0, ihdu)
   327  	}
   328  
   329  	// move to hdu by name
   330  	err = f.SeekHDUByName(BINARY_TBL, "IUE MELO", 1)
   331  	if err != nil {
   332  		t.Fatalf("error hdu-nam: %v", err)
   333  	}
   334  
   335  	ihdu = f.HDUNum()
   336  	if ihdu != 1 {
   337  		t.Fatalf("expected hdu number [%v]. got [%v]", 1, ihdu)
   338  	}
   339  
   340  }
   341  
   342  func TestOpen(t *testing.T) {
   343  	for _, table := range g_tables {
   344  		f, err := Open(table.fname, ReadOnly)
   345  		if err != nil {
   346  			t.Fatalf("error opening file [%v]: %v", table.fname, err)
   347  		}
   348  		fmode, err := f.Mode()
   349  		if err != nil {
   350  			t.Fatalf("error mode: %v", err)
   351  		}
   352  		if fmode != ReadOnly {
   353  			t.Fatalf("expected file-mode [%v]. got [%v]", ReadOnly, fmode)
   354  		}
   355  
   356  		name, err := f.Name()
   357  		if err != nil {
   358  			t.Fatalf("error name: %v", err)
   359  		}
   360  		if name != table.fname {
   361  			t.Fatalf("expected file-name [%v]. got [%v]", table.fname, name)
   362  		}
   363  
   364  		furl, err := f.UrlType()
   365  		if err != nil {
   366  			t.Fatalf("error url: %v", err)
   367  		}
   368  		if furl != "file://" {
   369  			t.Fatalf("expected file-url [%v]. got [%v]", "file://", furl)
   370  		}
   371  		if len(f.HDUs()) != len(table.hdus) {
   372  			t.Fatalf("#hdus. expected %v. got %v", len(table.hdus), len(f.HDUs()))
   373  		}
   374  	}
   375  }
   376  
   377  func TestCreateFile(t *testing.T) {
   378  	curdir, err := os.Getwd()
   379  	if err != nil {
   380  		t.Fatalf(err.Error())
   381  	}
   382  	defer os.Chdir(curdir)
   383  
   384  	workdir, err := ioutil.TempDir("", "go-cfitsio-test-")
   385  	if err != nil {
   386  		t.Fatalf(err.Error())
   387  	}
   388  	defer os.RemoveAll(workdir)
   389  
   390  	err = os.Chdir(workdir)
   391  	if err != nil {
   392  		t.Fatalf(err.Error())
   393  	}
   394  
   395  	fname := "new.fits"
   396  	f, err := Create(fname)
   397  	if err != nil {
   398  		t.Fatalf("error creating new file [%v]: %v", fname, err)
   399  	}
   400  	defer f.Close()
   401  
   402  	fmode, err := f.Mode()
   403  	if err != nil {
   404  		t.Fatalf("error mode: %v", err)
   405  	}
   406  	if fmode != ReadWrite {
   407  		t.Fatalf("expected file-mode [%v]. got [%v]", ReadWrite, fmode)
   408  	}
   409  
   410  	name, err := f.Name()
   411  	if err != nil {
   412  		t.Fatalf("error name: %v", err)
   413  	}
   414  	if name != fname {
   415  		t.Fatalf("expected file-name [%v]. got [%v]", fname, name)
   416  	}
   417  
   418  	furl, err := f.UrlType()
   419  	if err != nil {
   420  		t.Fatalf("error url: %v", err)
   421  	}
   422  	if furl != "file://" {
   423  		t.Fatalf("expected file-url [%v]. got [%v]", "file://", furl)
   424  	}
   425  	if len(f.HDUs()) != 0 {
   426  		t.Fatalf("#hdus. expected %v. got %v", 0, len(f.HDUs()))
   427  	}
   428  
   429  }
   430  
   431  // EOF