// FilePhysical_t.cxx

#include "FilePhysical.h"
#include <iostream>
#include "hesfile/FileTest.h"

using std::cout;
using std::endl;
using hes::File;
using hes::FilePhysical;

namespace {

class FilePhysicalTest :
  public FileTestHeader,
  public FilePhysical,
  public FileTestEvent,
  public FileTestRem {

private:  // data

  bool m_valid;

public:  // functions

  // Constructor.
  // Valid object if valid=true.
  FilePhysicalTest(bool valid, bool read_unlocked)
  : FilePhysical(read_unlocked), m_valid(valid) { }

  // Validity.
  bool is_valid() const { return m_valid; }

  void begin_file() { }
  void end_file() { }

};

}  // end namespace

int main() {

  string line = "--------------------------------------";
  cout << line << endl;

  // Create an invalid file.
  {
    FilePhysicalTest file(false,false);
    cout << file << endl;
    assert( ! file.is_valid() );
    cout << line << endl;
  }

  // Create a file that may not be read until it is locked.
  {
    FilePhysicalTest file(true,false);
    file.set_physical_name("file1.dat");
    cout << file << endl;
    assert( file.is_valid() );
    assert( file.physical_name().is_valid() );
    cout << line << endl;
    assert( file.close() == 0 );
    assert( ! file.is_open() );

    // READONLY open should fail for a file that does not exist.
    assert( file.open(File::READONLY) != 0 );
    cout << file << endl;
    assert( ! file.is_open() );
    assert( ! file.can_be_read() );
    assert( ! file.can_be_written() );

    // APPEND open should fail for a file that does not exist.
    assert( file.open(File::APPEND) != 0 );
    cout << file << endl;
    assert( ! file.is_open() );

    // NEW open should succeed for a file that does not exist.
    assert( file.open(File::NEW) == 0 );
    cout << file << endl;
    assert( file.is_open() );
    assert( ! file.is_locked() );
    assert( ! file.can_be_read() );   // locked file cannot be read
    assert( file.can_be_written() );
    assert( file.close() == 0 );
    assert( ! file.is_open() );

    // File now exists.

    // NEW open should fail for a file that does exist.
    assert( file.open(File::NEW) != 0 );
    cout << file << endl;
    assert( ! file.is_open() );

    // APPEND open should succeed for an unlocked file that does exist.
    assert( file.open(File::APPEND) == 0 );
    cout << file << endl;
    assert( file.is_open() );
    assert( ! file.is_locked() );
    assert( ! file.can_be_read() );
    assert( file.can_be_written() );
    assert( file.close() == 0 );
    assert( ! file.is_open() );

    // READONLY open should fail until file is locked for a file that does exist.
    assert( file.open(File::READONLY) != 0 );
    cout << file << endl;
    assert( ! file.is_open() );

    // Lock the file.
    assert( ! file.is_locked() );
    file.lock();
    assert( file.is_locked() );

    // READONLY open should succeed for a locked file that does exist.
    assert( file.open(File::READONLY) == 0 );
    cout << file << endl;
    assert( file.is_open() );
    assert( file.is_locked() );
    assert( file.can_be_read() );
    assert( ! file.can_be_written() );
    assert( file.close() == 0 );
    assert( ! file.is_open() );

    // APPEND open should fail for a locked file that does not exist.
    assert( file.open(File::APPEND) != 0 );
    cout << file << endl;
    assert( ! file.is_open() );

  }

  // Create a file that can be read unlocked.
  {
    FilePhysicalTest file(true,true);
    file.set_physical_name("file1.dat");
    cout << file << endl;
    assert( file.is_valid() );

    // READONLY open should succeed for an unlocked file that does exist.
    assert( file.open(File::READONLY) == 0 );
    cout << file << endl;
    assert( file.is_open() );
    assert( ! file.is_locked() );
    assert( file.can_be_read() );
    assert( ! file.can_be_written() );
    assert( file.close() == 0 );
    assert( ! file.is_open() );

  }

  return 0;

}