//  Copyright (c) 2005-2007 Hartmut Kaiser (hartmut.kaiser@gmail.com)
//  Copyright (c) 2005-2007 Andre Merzky (andre@merzky.net)
// 
//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/test/unit_test.hpp>
using boost::unit_test_framework::test_suite;

#include <boost/filesystem/path.hpp>
#include <boost/filesystem/operations.hpp>

#include "test_saga.hpp"
#include "test_file.hpp"
//#include "test_tempfile_helpers.hpp"

namespace test_file
{
    /////////////////////////////////////////////////////////////////////////////
    void test_functions::test_get_url()
    {
        saga::session s;     // reload adaptors with the new environment settings

        namespace fs = boost::filesystem;
        
        //fs::path file1(util::generate_path_for_temp_file());
        //fs::path file2(util::generate_path_for_temp_file());
        //fs::path file3(util::generate_path_for_temp_file());
        //fs::path file4(util::generate_path_for_temp_file());
        
        std::string file1(utils_->create_temp_file_name(true));
        //std::cout << file1 << std::endl;
        std::string file2(utils_->create_temp_file_name(true));
        std::string file3(utils_->create_temp_file_name(true));
        std::string file4(utils_->create_temp_file_name(true));
        
        std::string url_1;
        std::string url_2;
        std::string url_3;
        std::string url_4;

        {
            saga::task t_1;
            saga::task t_2;
            saga::task t_3;

            //std::string prefix("file://localhost/");

            {
                saga::file f_1 (s, file1); //prefix + file1.string());
                saga::file f_2 (s, file2); //prefix + file2.string());
                saga::file f_3 (s, file3); //prefix + file3.string());
                saga::file f_4 (s, file4); //prefix + file4.string());

                url_1 = f_1.get_url                     (     );
                t_1   = f_2.get_url <saga::task::Sync>  (url_2);
                t_2   = f_3.get_url <saga::task::Async> (url_3);
                t_3   = f_4.get_url <saga::task::Task>  (url_4);
            }

            BOOST_CHECK_EQUAL (t_1.get_state (), saga::task::Done);
            BOOST_CHECK (t_2.get_state () == saga::task::Running || 
                        t_2.get_state () == saga::task::Done    );
            BOOST_CHECK_EQUAL (t_3.get_state (), saga::task::New);

            t_3.run ();

            BOOST_CHECK (t_3.get_state () == saga::task::Running || 
                        t_3.get_state () == saga::task::Done    );

            t_2.wait ();
            t_3.wait ();

            BOOST_CHECK_EQUAL (t_2.get_state (), saga::task::Done);
            BOOST_CHECK_EQUAL (t_3.get_state (), saga::task::Done);

            BOOST_CHECK_EQUAL (url_1, file1); //prefix + file1.string());
            BOOST_CHECK_EQUAL (url_2, file2); //prefix + file2.string());
            BOOST_CHECK_EQUAL (url_3, file3); //prefix + file3.string());
            BOOST_CHECK_EQUAL (url_4, file4); //prefix + file4.string());
        }
    }

    void test_functions::get_url (void)
    {
        // test with both (sync/async) adaptor supplied implementations available
        prep_environment env1 ("SAGA_RUN_SYNC",  "1");
        prep_environment env2 ("SAGA_RUN_ASYNC", "1");

        test_get_url ();
    }

    void test_functions::sync_get_url (void)
    {
        // test with sync adaptor supplied implementations available
        prep_environment env ("SAGA_RUN_SYNC", "1");

        test_get_url ();
    }

    void test_functions::async_get_url (void)
    {
        // test with async adaptor supplied implementations available
        prep_environment env2 ("SAGA_RUN_ASYNC", "1");

        test_get_url ();
    }

    ///////////////////////////////////////////////////////////////////////////
    void test_functions::test_get_cwd (void)
    {
        saga::session s;     // reload adaptors with the new environment settings

        namespace fs = boost::filesystem;

        std::string file1(utils_->create_temp_file_name(true));
        std::string file2(utils_->create_temp_file_name(true));
        std::string file3(utils_->create_temp_file_name(true));
        std::string file4(utils_->create_temp_file_name(true));
        
        saga::url url_1(file1);
        saga::url url_2(file2);
        saga::url url_3(file3);
        saga::url url_4(file4);

        std::string cwd_1;
        std::string cwd_2;
        std::string cwd_3;
        std::string cwd_4;

        {
            saga::task t_1;
            saga::task t_2;
            saga::task t_3;

            //std::string prefix("file://localhost/");

            {
              saga::file f_1 (s, file1); //prefix + file1.string());
              saga::file f_2 (s, file2); //prefix + file2.string());
              saga::file f_3 (s, file3); //prefix + file3.string());
              saga::file f_4 (s, file4); //prefix + file4.string());
              
                cwd_1 = f_1.get_cwd                     (     );
                t_1   = f_2.get_cwd <saga::task::Sync>  (cwd_2);
                t_2   = f_3.get_cwd <saga::task::Async> (cwd_3);
                t_3   = f_4.get_cwd <saga::task::Task>  (cwd_4);
            }

            BOOST_CHECK (t_1.get_state () == saga::task::Done    );
            BOOST_CHECK (t_2.get_state () == saga::task::Running || 
                         t_2.get_state () == saga::task::Done    );
            BOOST_CHECK (t_3.get_state () == saga::task::New );

            t_3.run ();

            BOOST_CHECK (t_3.get_state () == saga::task::Running || 
                         t_3.get_state () == saga::task::Done    );

            t_2.wait ();
            t_3.wait ();

            BOOST_CHECK (t_2.get_state () == saga::task::Done    );
            BOOST_CHECK (t_3.get_state () == saga::task::Done    );
            
            std::string path1 = std::string(url_1.get_scheme()
                                            +"://"
                                            +url_1.get_host()+"/"
                                            +(boost::filesystem::path(url_1.get_path())).branch_path().string()
                                            +"/"
                                            );
            BOOST_CHECK_EQUAL (cwd_1, path1);
            
            std::string path2 = std::string(url_2.get_scheme()
                                            +"://"
                                            +url_2.get_host()+"/"
                                            +(boost::filesystem::path(url_2.get_path())).branch_path().string()
                                            +"/"
                                            );
            BOOST_CHECK_EQUAL (cwd_2, path2);
            
            std::string path3 = std::string(url_3.get_scheme()
                                            +"://"
                                            +url_3.get_host()+"/"
                                            +(boost::filesystem::path(url_3.get_path())).branch_path().string()
                                            +"/"
                                            );
            BOOST_CHECK_EQUAL (cwd_3, path2);
            
            std::string path4 = std::string(url_4.get_scheme()
                                            +"://"
                                            +url_4.get_host()+"/"
                                            +(boost::filesystem::path(url_4.get_path())).branch_path().string()
                                            +"/"
                                            );
            BOOST_CHECK_EQUAL (cwd_4, path4);

        }
    }

    void test_functions::get_cwd (void)
    {
        // test with both (sync/async) adaptor supplied implementations available
        prep_environment env1 ("SAGA_RUN_SYNC",  "1");
        prep_environment env2 ("SAGA_RUN_ASYNC", "1");

        test_get_cwd ();
    }

    void test_functions::sync_get_cwd (void)
    {
        // test with sync adaptor supplied implementations available
        prep_environment env ("SAGA_RUN_SYNC", "1");

        test_get_cwd ();
    }

    void test_functions::async_get_cwd (void)
    {
        // test with async adaptor supplied implementations available
        prep_environment env2 ("SAGA_RUN_ASYNC", "1");

        test_get_cwd ();
    }

    ///////////////////////////////////////////////////////////////////////////
    void test_functions::test_get_name (void)
    {
        saga::session s;     // reload adaptors with the new environment settings

        namespace fs = boost::filesystem;

        std::string name_1;
        std::string name_2;
        std::string name_3;
        std::string name_4;

        std::string file1(utils_->create_temp_file_name(true));
        std::string file2(utils_->create_temp_file_name(true));
        std::string file3(utils_->create_temp_file_name(true));
        std::string file4(utils_->create_temp_file_name(true));
        
        saga::url url_1(file1);
        saga::url url_2(file2);
        saga::url url_3(file3);
        saga::url url_4(file4);

        {
            saga::task t_1;
            saga::task t_2;
            saga::task t_3;

            {
                {
                  saga::file f_1 (s, file1); 
                  saga::file f_2 (s, file2); 
                  saga::file f_3 (s, file3); 
                  saga::file f_4 (s, file4); 

                    name_1 = f_1.get_name                     (     );
                    t_1    = f_2.get_name <saga::task::Sync>  (name_2);
                    t_2    = f_3.get_name <saga::task::Async> (name_3);
                    t_3    = f_4.get_name <saga::task::Task>  (name_4);
                }

                BOOST_CHECK_EQUAL (t_1.get_state (), saga::task::Done);
                BOOST_CHECK (t_2.get_state () == saga::task::Running || 
                             t_2.get_state () == saga::task::Done    );
                BOOST_CHECK_EQUAL (t_3.get_state (), saga::task::New);

                t_3.run ();

                BOOST_CHECK (t_3.get_state () == saga::task::Running || 
                             t_3.get_state () == saga::task::Done    );

                t_2.wait ();
                t_3.wait ();

                BOOST_CHECK_EQUAL (t_2.get_state (), saga::task::Done);
                BOOST_CHECK_EQUAL (t_3.get_state (), saga::task::Done);

                BOOST_CHECK_EQUAL (name_1, (boost::filesystem::path(url_1.get_path())).leaf());
                BOOST_CHECK_EQUAL (name_2, (boost::filesystem::path(url_2.get_path())).leaf());
                BOOST_CHECK_EQUAL (name_3, (boost::filesystem::path(url_3.get_path())).leaf());
                BOOST_CHECK_EQUAL (name_4, (boost::filesystem::path(url_4.get_path())).leaf());
            }
        }
        
        //fs::remove(file1);
        //fs::remove(file2);
        //fs::remove(file3);
        //fs::remove(file4);
    }

    void test_functions::get_name (void)
    {
        // test with both (sync/async) adaptor supplied implementations available
        prep_environment env1 ("SAGA_RUN_SYNC", "1");
        prep_environment env2 ("SAGA_RUN_ASYNC", "1");

        test_get_name ();
    }

    void test_functions::sync_get_name (void)
    {
        // test with sync adaptor supplied implementations available
        prep_environment env ("SAGA_RUN_SYNC", "1");

        test_get_name ();
    }

    void test_functions::async_get_name (void)
    {
        // test with async adaptor supplied implementations available
        prep_environment env2 ("SAGA_RUN_ASYNC", "1");

        test_get_name ();
    }

    ///////////////////////////////////////////////////////////////////////////
    void test_functions::test_is_dir ()
    {
        saga::session s;     // reload adaptors with the new environment settings

        namespace fs = boost::filesystem;

        std::string file1(utils_->create_temp_file_name(true));
        std::string file2(utils_->create_temp_file_name(true));
        std::string file3(utils_->create_temp_file_name(true));
        std::string file4(utils_->create_temp_file_name(true));

        bool is_dir1 = true;
        bool is_dir2 = true;
        bool is_dir3 = true;
        bool is_dir4 = true;

        {
            saga::task t_1;
            saga::task t_2;
            saga::task t_3;

            {
                saga::file f_1 (s, file1);
                saga::file f_2 (s, file2);
                saga::file f_3 (s, file3);
                saga::file f_4 (s, file4);

                is_dir1 = f_1.is_dir();
                t_1     = f_2.is_dir<saga::task::Sync>  (is_dir2);
                t_2     = f_3.is_dir<saga::task::Async> (is_dir3);
                t_3     = f_4.is_dir<saga::task::Task>  (is_dir4);
            }

            BOOST_CHECK_EQUAL (t_1.get_state (), saga::task::Done);
            BOOST_CHECK (t_2.get_state () == saga::task::Running || 
                         t_2.get_state () == saga::task::Done    );
            BOOST_CHECK_EQUAL (t_3.get_state (), saga::task::New);

            t_3.run ();

            BOOST_CHECK (t_3.get_state () == saga::task::Running || 
                         t_3.get_state () == saga::task::Done    );

            t_2.wait ();
            t_3.wait ();

            BOOST_CHECK_EQUAL (t_2.get_state (), saga::task::Done);
            BOOST_CHECK_EQUAL (t_3.get_state (), saga::task::Done);

            BOOST_CHECK (!is_dir1);
            BOOST_CHECK (!is_dir2);
            BOOST_CHECK (!is_dir3);
            BOOST_CHECK (!is_dir4);

        }
        
        //fs::remove(file1);
        //fs::remove(file2);
        //fs::remove(file3);
        //fs::remove(file4);
    }

    void test_functions::is_dir()
    {
        // test with both (sync/async) adaptor supplied implementations available
        prep_environment env1("SAGA_RUN_SYNC", "1");
        prep_environment env2("SAGA_RUN_ASYNC", "1");
        test_is_dir();
    }

    void test_functions::sync_is_dir()
    {
        // test with sync adaptor supplied implementations available
        prep_environment env("SAGA_RUN_SYNC", "1");
        test_is_dir();
    }

    void test_functions::async_is_dir()
    {
        // test with async adaptor supplied implementations available
        prep_environment env("SAGA_RUN_ASYNC", "1");
        test_is_dir();
    }

    ///////////////////////////////////////////////////////////////////////////
    void test_functions::test_is_entry ()
    {
        saga::session s;     // reload adaptors with the new environment settings

        namespace fs = boost::filesystem;

        // generate_path_for_temp_file creates a file
        std::string file1(utils_->create_temp_file_name(true));
        std::string file2(utils_->create_temp_file_name(true));
        std::string file3(utils_->create_temp_file_name(true));
        std::string file4(utils_->create_temp_file_name(true));

        bool is_entry1 = false;
        bool is_entry2 = false;
        bool is_entry3 = false;
        bool is_entry4 = false;

        {
            saga::task t_1;
            saga::task t_2;
            saga::task t_3;

            // first test with an absolute name
            {
                saga::file f_1 (s, file1);
                saga::file f_2 (s, file2);
                saga::file f_3 (s, file3);
                saga::file f_4 (s, file4);

                is_entry1 = f_1.is_entry ();
                t_1       = f_2.is_entry <saga::task::Sync>  (is_entry2);
                t_2       = f_3.is_entry <saga::task::Async> (is_entry3);
                t_3       = f_4.is_entry <saga::task::Task>  (is_entry4);
            }

            BOOST_CHECK_EQUAL (t_1.get_state (), saga::task::Done);
            BOOST_CHECK (t_2.get_state () == saga::task::Running || 
                        t_2.get_state () == saga::task::Done    );
            BOOST_CHECK_EQUAL (t_3.get_state (), saga::task::New);

            t_3.run ();

            BOOST_CHECK (t_3.get_state () == saga::task::Running || 
                        t_3.get_state () == saga::task::Done    );

            t_2.wait ();
            t_3.wait ();

            BOOST_CHECK_EQUAL (t_2.get_state (), saga::task::Done);
            BOOST_CHECK_EQUAL (t_3.get_state (), saga::task::Done);

            BOOST_CHECK(is_entry1);
            BOOST_CHECK(is_entry2);
            BOOST_CHECK(is_entry3);
            BOOST_CHECK(is_entry4);
        }
        
        // done with the tests
        //fs::remove (tfile);   // remove the file
    }

    void test_functions::is_entry (void)
    {
        // test with both (sync/async) adaptor supplied implementations available
        prep_environment env1 ("SAGA_RUN_SYNC",  "1");
        prep_environment env2 ("SAGA_RUN_ASYNC", "1");

        test_is_entry ();
        test_is_entry ();
    }
    void test_functions::sync_is_entry (void)
    {
        // test with sync adaptor supplied implementations available
        prep_environment env ("SAGA_RUN_SYNC", "1");

        test_is_entry ();
        test_is_entry ();
    }
    void test_functions::async_is_entry (void)
    {
        // test with async adaptor supplied implementations available
        prep_environment env ("SAGA_RUN_ASYNC", "1");

        test_is_entry ();
        test_is_entry ();
    }

#if BOOST_VERSION >= 103400
    ///////////////////////////////////////////////////////////////////////////
    void test_functions::test_is_link (bool is_link)
    {
        saga::session s;     // reload adaptors with the new environment settings

        namespace fs = boost::filesystem;

        // generate_path_for_temp_file creates a file
        std::string file1(utils_->create_temp_file_name(true));
        std::string file2(utils_->create_temp_file_name(true));
        std::string file3(utils_->create_temp_file_name(true));
        std::string file4(utils_->create_temp_file_name(true));

        bool is_link1 = !is_link;
        bool is_link2 = !is_link;
        bool is_link3 = !is_link;
        bool is_link4 = !is_link;

        {
            saga::task t_1;
            saga::task t_2;
            saga::task t_3;

            // first test with an absolute name
            {
                saga::file f_1 (s, file1);
                saga::file f_2 (s, file2);
                saga::file f_3 (s, file3);
                saga::file f_4 (s, file4);

                is_link1 = f_1.is_link ();
                t_1      = f_2.is_link <saga::task::Sync>  (is_link2);
                t_2      = f_3.is_link <saga::task::Async> (is_link3);
                t_3      = f_4.is_link <saga::task::Task>  (is_link4);
            }

            BOOST_CHECK_EQUAL (t_1.get_state (), saga::task::Done);
            BOOST_CHECK (t_2.get_state () == saga::task::Running || 
                        t_2.get_state () == saga::task::Done    );
            BOOST_CHECK_EQUAL (t_3.get_state (), saga::task::New);

            t_3.run ();

            BOOST_CHECK (t_3.get_state () == saga::task::Running || 
                        t_3.get_state () == saga::task::Done    );

            t_2.wait ();
            t_3.wait ();

            BOOST_CHECK_EQUAL (t_2.get_state (), saga::task::Done);
            BOOST_CHECK_EQUAL (t_3.get_state (), saga::task::Done);

            BOOST_CHECK_EQUAL(is_link1, is_link);
            BOOST_CHECK_EQUAL(is_link2, is_link);
            BOOST_CHECK_EQUAL(is_link3, is_link);
            BOOST_CHECK_EQUAL(is_link4, is_link);
        }

        // done with the tests
        //fs::remove (tfile);   // remove the file
    }

    void test_functions::is_link (void)
    {
        // test with both (sync/async) adaptor supplied implementations available
        prep_environment env1 ("SAGA_RUN_SYNC",  "1");
        prep_environment env2 ("SAGA_RUN_ASYNC", "1");

//        test_is_link (true);
        test_is_link (false);
    }

    void test_functions::sync_is_link (void)
    {
        // test with sync adaptor supplied implementations available
        prep_environment env ("SAGA_RUN_SYNC", "1");

//        test_is_link (true);
        test_is_link (false);
    }
    void test_functions::async_is_link (void)
    {
        // test with async adaptor supplied implementations available
        prep_environment env ("SAGA_RUN_ASYNC", "1");

//        test_is_link (true);
        test_is_link (false);
    }
#endif  // BOOST_VERSION >= 103400

    ///////////////////////////////////////////////////////////////////////////
    void test_functions::test_read_write()
    {
        saga::session s;     // reload adaptors with the new environment settings
        
        namespace fs = boost::filesystem;
        const char txt[] = "Some test string";
        char inbuff[64];
        
        std::fill(inbuff, &inbuff[64], 0);
        
        // test synchronous API
        {
            std::string file1(utils_->create_temp_file_name(false));
            
            {
                saga::file f (file1, saga::file::Create|saga::file::ReadWrite);
                BOOST_CHECK_EQUAL(ssize_t(sizeof(txt)), f.write (txt, sizeof(txt)));
                BOOST_CHECK_EQUAL(0, f.seek  (0, saga::file::Start));
                BOOST_CHECK_EQUAL(ssize_t(sizeof(txt)), f.read  (inbuff, sizeof(inbuff)));
                BOOST_CHECK_EQUAL(std::string(inbuff), std::string(txt));
                BOOST_CHECK_EQUAL(off_t(sizeof(txt)),   f.get_size());
            }
            //fs::remove(tempname);
        }
      
        // test explicit synchronous API
        {
            std::string file1(utils_->create_temp_file_name(false));
            
            saga::ssize_t writtenbytes = 0;
            saga::off_t offset = 0;
            saga::ssize_t readbytes = 0;
            saga::off_t file_size = 0;
            
            {
                saga::task t_1;
                saga::task t_2;
                saga::task t_3;
                saga::task t_4;

                {
                    saga::file f (file1, saga::file::Create|saga::file::ReadWrite);
                    t_1 = f.write<saga::task::Sync>(writtenbytes, txt, sizeof(txt));
                    t_2 = f.seek<saga::task::Sync>(offset, 0, saga::file::Start);
                    t_3 = f.read<saga::task::Sync>(readbytes, inbuff, sizeof(inbuff));

                    t_4 = f.get_size<saga::task::Sync>(file_size);
                }
                            
                BOOST_CHECK_EQUAL(t_1.get_state(), saga::task::Done);
                BOOST_CHECK_EQUAL(t_2.get_state(), saga::task::Done);
                BOOST_CHECK_EQUAL(t_3.get_state(), saga::task::Done);
                BOOST_CHECK_EQUAL(t_4.get_state(), saga::task::Done);

                BOOST_CHECK_EQUAL(ssize_t(sizeof(txt)), writtenbytes);
                BOOST_CHECK_EQUAL(0, offset);
                BOOST_CHECK_EQUAL(ssize_t(sizeof(txt)), readbytes);
                BOOST_CHECK_EQUAL(std::string(inbuff),  std::string(txt));
                BOOST_CHECK_EQUAL(off_t(sizeof(txt)),   file_size);
            }

            //fs::remove(tempname);
        }

        // test asynchronous API
        {
            std::string file1(utils_->create_temp_file_name(false));
            
            saga::ssize_t writtenbytes = 0;
            saga::off_t offset = 0;
            saga::ssize_t readbytes = 0;
            saga::off_t file_size = 0;

            {            
                saga::task t_1;
                saga::task t_2;
                saga::task t_3;
                saga::task t_4;

                {
                    saga::file f (file1, saga::file::Create|saga::file::ReadWrite);
                    t_1 = f.write<saga::task::Async>(writtenbytes, txt, sizeof(txt));
                    t_1.wait ();
                    t_2 = f.seek<saga::task::Async>(offset, 0, saga::file::Start);
                    t_2.wait ();
                    t_3 = f.read<saga::task::Async>(readbytes, inbuff, sizeof(inbuff));
                    t_3.wait ();
                    t_4 = f.get_size<saga::task::Async>(file_size);
                }
                            
                t_4.wait ();

                BOOST_CHECK_EQUAL(t_1.get_state(), saga::task::Done);
                BOOST_CHECK_EQUAL(t_2.get_state(), saga::task::Done);
                BOOST_CHECK_EQUAL(t_3.get_state(), saga::task::Done);
                BOOST_CHECK_EQUAL(t_4.get_state(), saga::task::Done);
            }
            
            BOOST_CHECK_EQUAL(ssize_t(sizeof(txt)), writtenbytes);
            BOOST_CHECK_EQUAL(0, offset);
            BOOST_CHECK_EQUAL(ssize_t(sizeof(txt)), readbytes);
            BOOST_CHECK_EQUAL(std::string(inbuff),  std::string(txt));
            BOOST_CHECK_EQUAL(off_t(sizeof(txt)),   file_size);

            //fs::remove(tempname);
        }
    }

    ///////////////////////////////////////////////////////////////////////////
    void test_functions::read_write()
    {
        // test with both (sync/async) adaptor supplied implementations available
        prep_environment env1("SAGA_RUN_SYNC", "1");
        prep_environment env2("SAGA_RUN_ASYNC", "1");
        test_read_write();
    }

    ///////////////////////////////////////////////////////////////////////////
    void test_functions::sync_read_write()
    {
        // test with sync adaptor supplied implementations available
        prep_environment env("SAGA_RUN_SYNC", "1");
        test_read_write();
    }

    ///////////////////////////////////////////////////////////////////////////
    void test_functions::async_read_write()
    {
        // test with async adaptor supplied implementations available
        prep_environment env("SAGA_RUN_ASYNC", "1");
        test_read_write();
    }

    ///////////////////////////////////////////////////////////////////////////
    void test_functions::test_read_write_buf()
    {
        saga::session s;     // reload adaptors with the new environment settings
        
        namespace fs = boost::filesystem;
        const char txt[] = "Some test string";
        char inbuff[64];
        
        std::fill(inbuff, &inbuff[64], 0);
        
        // test synchronous API
        {
          //fs::path tempname(utils_->create_temp_file_name(false));
          std::string tempname(utils_->create_temp_file_name(false));
            {
                saga::file f (tempname, saga::file::Create|saga::file::ReadWrite);
                BOOST_CHECK_EQUAL(ssize_t(sizeof(txt)), f.write (saga::buffer(txt)));
                BOOST_CHECK_EQUAL(0, f.seek  (0, saga::file::Start));
                BOOST_CHECK_EQUAL(ssize_t(sizeof(txt)), f.read  (saga::buffer(inbuff)));
                BOOST_CHECK_EQUAL(std::string(inbuff), std::string(txt));
                BOOST_CHECK_EQUAL(off_t(sizeof(txt)),   f.get_size());
            }
            //fs::remove(tempname);
        }
      
        // test explicit synchronous API
        {
           // fs::path tempname(utils_->create_temp_file_name(false));
           std::string tempname(utils_->create_temp_file_name(false));
            
            saga::ssize_t writtenbytes = 0;
            saga::off_t offset = 0;
            saga::ssize_t readbytes = 0;
            saga::off_t file_size = 0;
            
            {
                saga::task t_1;
                saga::task t_2;
                saga::task t_3;
                saga::task t_4;

                {
                    saga::file f (tempname, saga::file::Create|saga::file::ReadWrite);
                    t_1 = f.write<saga::task::Sync>(writtenbytes, saga::buffer(txt));
                    t_2 = f.seek<saga::task::Sync>(offset, 0, saga::file::Start);
                    t_3 = f.read<saga::task::Sync>(readbytes, saga::buffer(inbuff));

                    t_4 = f.get_size<saga::task::Sync>(file_size);
                }
                            
                BOOST_CHECK_EQUAL(t_1.get_state(), saga::task::Done);
                BOOST_CHECK_EQUAL(t_2.get_state(), saga::task::Done);
                BOOST_CHECK_EQUAL(t_3.get_state(), saga::task::Done);
                BOOST_CHECK_EQUAL(t_4.get_state(), saga::task::Done);

                BOOST_CHECK_EQUAL(ssize_t(sizeof(txt)), writtenbytes);
                BOOST_CHECK_EQUAL(0, offset);
                BOOST_CHECK_EQUAL(ssize_t(sizeof(txt)), readbytes);
                BOOST_CHECK_EQUAL(std::string(inbuff),  std::string(txt));
                BOOST_CHECK_EQUAL(off_t(sizeof(txt)),   file_size);
            }

            //fs::remove(tempname);
        }

        // test asynchronous API
        {
          //  fs::path tempname(utils_->create_temp_file_name(false));
           std::string tempname(utils_->create_temp_file_name(false));
            
            saga::ssize_t writtenbytes = 0;
            saga::off_t offset = 0;
            saga::ssize_t readbytes = 0;
            saga::off_t file_size = 0;

            {            
                saga::task t_1;
                saga::task t_2;
                saga::task t_3;
                saga::task t_4;

                {
                    saga::file f (tempname, saga::file::Create|saga::file::ReadWrite);
                    t_1 = f.write<saga::task::Async>(writtenbytes, saga::buffer(txt));
                    t_1.wait ();
                    t_2 = f.seek<saga::task::Async>(offset, 0, saga::file::Start);
                    t_2.wait ();
                    t_3 = f.read<saga::task::Async>(readbytes, saga::buffer(inbuff));
                    t_3.wait ();
                    t_4 = f.get_size<saga::task::Async>(file_size);
                }
                            
                t_4.wait ();

                BOOST_CHECK_EQUAL(t_1.get_state(), saga::task::Done);
                BOOST_CHECK_EQUAL(t_2.get_state(), saga::task::Done);
                BOOST_CHECK_EQUAL(t_3.get_state(), saga::task::Done);
                BOOST_CHECK_EQUAL(t_4.get_state(), saga::task::Done);
            }
            
            BOOST_CHECK_EQUAL(ssize_t(sizeof(txt)), writtenbytes);
            BOOST_CHECK_EQUAL(0, offset);
            BOOST_CHECK_EQUAL(ssize_t(sizeof(txt)), readbytes);
            BOOST_CHECK_EQUAL(std::string(inbuff),  std::string(txt));
            BOOST_CHECK_EQUAL(off_t(sizeof(txt)),   file_size);

            //fs::remove(tempname);
        }
    }

    ///////////////////////////////////////////////////////////////////////////
    void test_functions::read_write_buf()
    {
        // test with both (sync/async) adaptor supplied implementations available
        prep_environment env1("SAGA_RUN_SYNC", "1");
        prep_environment env2("SAGA_RUN_ASYNC", "1");
        test_read_write_buf();
    }

    ///////////////////////////////////////////////////////////////////////////
    void test_functions::sync_read_write_buf()
    {
        // test with sync adaptor supplied implementations available
        prep_environment env("SAGA_RUN_SYNC", "1");
        test_read_write_buf();
    }

    ///////////////////////////////////////////////////////////////////////////
    void test_functions::async_read_write_buf()
    {
        // test with async adaptor supplied implementations available
        prep_environment env("SAGA_RUN_ASYNC", "1");
        test_read_write_buf();
    }
}