// VolumeTest.cpp

#include <stdio.h>
#include <string>
#include <unistd.h>

#include <Application.h>
#include <Bitmap.h>
#include <Directory.h>
#include <Entry.h>
#include <File.h>
#include <fs_attr.h>
#include <fs_info.h>
#include <Node.h>
#include <NodeMonitor.h>
#include <Path.h>
#include <Resources.h>
#include <Roster.h>
#include <String.h>
#include <TypeConstants.h>
#include <Volume.h>
#include <VolumeRoster.h>

#include <cppunit/Test.h>
#include <cppunit/TestCaller.h>
#include <cppunit/TestSuite.h>
#include <TestApp.h>
#include <TestShell.h>
#include <TestUtils.h>
#include <cppunit/TestAssert.h>

#include "VolumeTest.h"
#include "../app/bmessenger/Helpers.h"

// test dirs/files/types
static const char *testDir                      = "/tmp/testDir";
static const char *testFile1            = "/tmp/testDir/file1";
static const char *testMountPoint       = "/tmp/testDir/mount_point";

// icon_equal
static
bool
icon_equal(const BBitmap *icon1, const BBitmap *icon2)
{
        return (icon1->Bounds() == icon2->Bounds()
                        && icon1->BitsLength() == icon2->BitsLength()
                        && memcmp(icon1->Bits(), icon2->Bits(), icon1->BitsLength()) == 0);
}

// Suite
CppUnit::Test*
VolumeTest::Suite() {
        CppUnit::TestSuite *suite = new CppUnit::TestSuite();
        typedef CppUnit::TestCaller<VolumeTest> TC;
                
        suite->addTest( new TC("BVolume::Init Test1",
                                                   &VolumeTest::InitTest1) );
        suite->addTest( new TC("BVolume::Init Test2",
                                                   &VolumeTest::InitTest2) );
        suite->addTest( new TC("BVolume::Assignment Test",
                                                   &VolumeTest::AssignmentTest) );
        suite->addTest( new TC("BVolume::Comparisson Test",
                                                   &VolumeTest::ComparissonTest) );
        suite->addTest( new TC("BVolume::SetName Test",
                                                   &VolumeTest::SetNameTest) );
        suite->addTest( new TC("BVolume::BadValues Test",
                                                   &VolumeTest::BadValuesTest) );
        suite->addTest( new TC("BVolumeRoster::Iteration Test",
                                                   &VolumeTest::IterationTest) );
        suite->addTest( new TC("BVolumeRoster::Watching Test",
                                                   &VolumeTest::WatchingTest) );

        return suite;
}               

// setUp
void
VolumeTest::setUp()
{
        BasicTest::setUp();
        // create test dir and files
        execCommand(
                string("mkdir ") + testDir
        );
        // create and mount image
        createVolume(testFile1, testMountPoint, 1);
        // create app
        fApplication = new BTestApp("application/x-vnd.obos.volume-test");
        if (fApplication->Init() != B_OK) {
                fprintf(stderr, "Failed to initialize application.\n");
                delete fApplication;
                fApplication = NULL;
        }
}
        
// tearDown
void
VolumeTest::tearDown()
{
        // delete the application
        if (fApplication) {
                fApplication->Terminate();
                delete fApplication;
                fApplication = NULL;
        }
        // unmount and delete image
        deleteVolume(testFile1, testMountPoint);
        // delete the test dir
        execCommand(string("rm -rf ") + testDir);

        BasicTest::tearDown();
}

// CheckVolume
static
void
CheckVolume(BVolume &volume, dev_t device, status_t error)
{
        CHK(volume.InitCheck() == error);
        if (error == B_OK) {
                fs_info info;
                CHK(fs_stat_dev(device, &info) == 0);
                // device
                CHK(volume.Device() == device);
                // root dir
                BDirectory rootDir;
                CHK(volume.GetRootDirectory(&rootDir) == B_OK);
                node_ref rootNode;
                rootNode.device = device;
                rootNode.node = info.root;
                BDirectory actualRootDir(&rootNode);
                CHK(rootDir == actualRootDir);
                // capacity, free bytes
                CHK(volume.Capacity() == info.total_blocks * info.block_size);
                CHK(volume.FreeBytes() == info.free_blocks * info.block_size);
                // name
                char name[B_FILE_NAME_LENGTH];
                CHK(volume.GetName(name) == B_OK);
                CHK(BString(name) == info.volume_name);
                // icons
                // mini
                BBitmap miniIcon(BRect(0, 0, 15, 15), B_CMAP8);
                BBitmap miniIcon2(BRect(0, 0, 15, 15), B_CMAP8);
                status_t iconError = get_device_icon(info.device_name,
                                                                                         miniIcon2.Bits(), B_MINI_ICON);
                CHK(volume.GetIcon(&miniIcon, B_MINI_ICON) == iconError);
                if (iconError == B_OK)
                        CHK(icon_equal(&miniIcon, &miniIcon2));
                // large
                BBitmap largeIcon(BRect(0, 0, 31, 31), B_CMAP8);
                BBitmap largeIcon2(BRect(0, 0, 31, 31), B_CMAP8);
                iconError = get_device_icon(info.device_name, largeIcon2.Bits(),
                                                                        B_LARGE_ICON);
                CHK(volume.GetIcon(&largeIcon, B_LARGE_ICON) == iconError);
                if (iconError == B_OK)
                        CHK(icon_equal(&largeIcon, &largeIcon2));
                // flags
                CHK(volume.IsRemovable() == bool(info.flags & B_FS_IS_REMOVABLE));
                CHK(volume.IsReadOnly() == bool(info.flags & B_FS_IS_READONLY));
                CHK(volume.IsPersistent() == bool(info.flags & B_FS_IS_PERSISTENT));
                CHK(volume.IsShared() == bool(info.flags & B_FS_IS_SHARED));
                CHK(volume.KnowsMime() == bool(info.flags & B_FS_HAS_MIME));
                CHK(volume.KnowsAttr() == bool(info.flags & B_FS_HAS_ATTR));
                CHK(volume.KnowsQuery() == bool(info.flags & B_FS_HAS_QUERY));
        } else {
                CHK(volume.Device() == -1);
                // root dir
                BDirectory rootDir;
                CHK(volume.GetRootDirectory(&rootDir) == B_BAD_VALUE);
                // capacity, free bytes
                CHK(volume.Capacity() == B_BAD_VALUE);
                CHK(volume.FreeBytes() == B_BAD_VALUE);
                // name
                char name[B_FILE_NAME_LENGTH];
                CHK(volume.GetName(name) == B_BAD_VALUE);
                // icons
                // mini
                BBitmap miniIcon(BRect(0, 0, 15, 15), B_CMAP8);
                CHK(volume.GetIcon(&miniIcon, B_MINI_ICON) == B_BAD_VALUE);
                // large
                BBitmap largeIcon(BRect(0, 0, 31, 31), B_CMAP8);
                CHK(volume.GetIcon(&largeIcon, B_LARGE_ICON) == B_BAD_VALUE);
                // flags
                CHK(volume.IsRemovable() == false);
                CHK(volume.IsReadOnly() == false);
                CHK(volume.IsPersistent() == false);
                CHK(volume.IsShared() == false);
                CHK(volume.KnowsMime() == false);
                CHK(volume.KnowsAttr() == false);
                CHK(volume.KnowsQuery() == false);
        }
}

// AssertNotBootVolume
static
void
AssertNotBootVolume(const BVolume &volume)
{
        CHK(volume.InitCheck() == B_OK);
        dev_t bootDevice = dev_for_path("/boot");
        CHK(bootDevice >= 0);
        CHK(volume.Device() != bootDevice);
}

// InitTest1
void
VolumeTest::InitTest1()
{
        // 1. BVolume(void)
        {
                BVolume volume;
                CheckVolume(volume, -1, B_NO_INIT);
        }
        // 2. BVolume(dev_t dev)
        // volumes for testing
        const char *volumes[] = {
                "/boot",
                "/",
                "/dev",
                "/pipe",
                "/unknown",
                testMountPoint
        };
        int32 volumeCount = sizeof(volumes) / sizeof(const char*);
        for (int32 i = 0; i < volumeCount; i++) {
                NextSubTest();
                const char *volumeRootDir = volumes[i];
                dev_t device = dev_for_path(volumeRootDir);
                BVolume volume(device);
                CheckVolume(volume, device, (device >= 0 ? B_OK : B_BAD_VALUE));
        }
        // invalid device ID
        NextSubTest();
        {
                BVolume volume(-2);
                CHK(volume.InitCheck() == B_BAD_VALUE);
        }
        // invalid device ID
        NextSubTest();
        {
                dev_t device = 213;
                fs_info info;
                while (fs_stat_dev(device, &info) == 0)
                        device++;
                BVolume volume(device);
                CHK(volume.InitCheck() == B_ENTRY_NOT_FOUND);
        }
}

// InitTest2
void
VolumeTest::InitTest2()
{
        // volumes for testing
        const char *volumes[] = {
                "/boot",
                "/",
                "/dev",
                "/pipe",
                "/unknown",
                testMountPoint
        };
        int32 volumeCount = sizeof(volumes) / sizeof(const char*);
        BVolume volume1;
        for (int32 i = 0; i < volumeCount; i++) {
                NextSubTest();
                const char *volumeRootDir = volumes[i];
                dev_t device = dev_for_path(volumeRootDir);
                status_t initError = (device >= 0 ? B_OK : B_BAD_VALUE);
                // reinit already initialized volume
                CHK(volume1.SetTo(device) == initError);
                CheckVolume(volume1, device, initError);
                // init fresh volume
                BVolume volume2;
                CHK(volume2.SetTo(device) == initError);
                CheckVolume(volume2, device, initError);
                // uninit volume
                volume2.Unset();
                CheckVolume(volume2, device, B_NO_INIT);
        }
        // invalid device ID
        NextSubTest();
        {
                BVolume volume;
                CHK(volume.SetTo(-2) == B_BAD_VALUE);
                CHK(volume.InitCheck() == B_BAD_VALUE);
        }
        // invalid device ID
        NextSubTest();
        {
                dev_t device = 213;
                fs_info info;
                while (fs_stat_dev(device, &info) == 0)
                        device++;
                BVolume volume;
                CHK(volume.SetTo(device) == B_ENTRY_NOT_FOUND);
                CHK(volume.InitCheck() == B_ENTRY_NOT_FOUND);
        }
}

// AssignmentTest
void
VolumeTest::AssignmentTest()
{
        // volumes for testing
        const char *volumes[] = {
                "/boot",
                "/",
                "/dev",
                "/pipe",
                "/unknown",
                testMountPoint
        };
        int32 volumeCount = sizeof(volumes) / sizeof(const char*);
        BVolume volume1;
        for (int32 i = 0; i < volumeCount; i++) {
                NextSubTest();
                const char *volumeRootDir = volumes[i];
                dev_t device = dev_for_path(volumeRootDir);
                status_t initError = (device >= 0 ? B_OK : B_BAD_VALUE);
                BVolume volume3(device);
                CheckVolume(volume3, device, initError);
                // assignment operation
                CHK(&(volume1 = volume3) == &volume1);
                CheckVolume(volume1, device, initError);
                // copy constructor
                BVolume volume2(volume3);
                CheckVolume(volume2, device, initError);
        }
}

// ComparissonTest
void
VolumeTest::ComparissonTest()
{
        // volumes for testing
        const char *volumes[] = {
                "/boot",
                "/",
                "/dev",
                "/pipe",
                "/unknown",
                testMountPoint
        };
        int32 volumeCount = sizeof(volumes) / sizeof(const char*);
        for (int32 i = 0; i < volumeCount; i++) {
                NextSubTest();
                const char *volumeRootDir = volumes[i];
                dev_t device = dev_for_path(volumeRootDir);
                status_t initError = (device >= 0 ? B_OK : B_BAD_VALUE);
                BVolume volume(device);
                CheckVolume(volume, device, initError);
                for (int32 k = 0; k < volumeCount; k++) {
                        const char *volumeRootDir2 = volumes[k];
                        dev_t device2 = dev_for_path(volumeRootDir2);
                        status_t initError2 = (device2 >= 0 ? B_OK : B_BAD_VALUE);
                        BVolume volume2(device2);
                        CheckVolume(volume2, device2, initError2);
                        bool equal = (i == k
                                                  || initError == initError2 && initError2 != B_OK);
                        CHK((volume == volume2) == equal);
                        CHK((volume != volume2) == !equal);
                }
        }
}

// SetNameTest
void
VolumeTest::SetNameTest()
{
        // status_t SetName(const char* name);
        dev_t device = dev_for_path(testMountPoint);
        BVolume volume(device);
        CheckVolume(volume, device, B_OK);
        AssertNotBootVolume(volume);
        // set a new name
        NextSubTest();
        const char *newName = "a new name";
        CHK(volume.SetName(newName) == B_OK);
        char name[B_FILE_NAME_LENGTH];
        CHK(volume.GetName(name) == B_OK);
        CHK(string(newName) == name);
        CheckVolume(volume, device, B_OK);
        // set another name
        NextSubTest();
        const char *newName2 = "another name";
        CHK(volume.SetName(newName2) == B_OK);
        CHK(volume.GetName(name) == B_OK);
        CHK(string(newName2) == name);
        CheckVolume(volume, device, B_OK);
        // GetName() with NULL buffer
// R5: crashes when passing a NULL pointer
#ifndef TEST_R5
        NextSubTest();
        CHK(volume.GetName(NULL) == B_BAD_VALUE);
#endif
        // bad name
// R5: crashes when passing a NULL pointer
#ifndef TEST_R5
        NextSubTest();
        CHK(volume.SetName(NULL) == B_BAD_VALUE);
#endif
        // uninitialized volume
        NextSubTest();
        volume.Unset();
        CHK(volume.SetName(newName) == B_BAD_VALUE);
}

// BadValuesTest
void
VolumeTest::BadValuesTest()
{
        BVolume volume(dev_for_path("/boot"));
        CHK(volume.InitCheck() == B_OK);
        // NULL arguments
// R5: crashes, when passing a NULL BDirectory.
#ifndef TEST_R5
        NextSubTest();
        CHK(volume.GetRootDirectory(NULL) == B_BAD_VALUE);
#endif
        NextSubTest();
        CHK(volume.GetIcon(NULL, B_MINI_ICON) == B_BAD_VALUE);
        CHK(volume.GetIcon(NULL, B_LARGE_ICON) == B_BAD_VALUE);
        // incompatible icon formats
// R5: returns B_OK
#ifndef TEST_R5
        NextSubTest();
        // mini
        BBitmap largeIcon(BRect(0, 0, 31, 31), B_CMAP8);
        CHK(volume.GetIcon(&largeIcon, B_MINI_ICON) == B_BAD_VALUE);
        // large
        BBitmap miniIcon(BRect(0, 0, 15, 15), B_CMAP8);
        CHK(volume.GetIcon(&miniIcon, B_LARGE_ICON) == B_BAD_VALUE);
#endif
}


// BVolumeRoster tests

//  GetAllDevices
static
void
GetAllDevices(set<dev_t> &devices)
{
//printf("GetAllDevices()\n");
        int32 cookie = 0;
        dev_t device;
        while ((device = next_dev(&cookie)) >= 0)
{
//printf("  device: %ld\n", device);
//BVolume dVolume(device);
//char name[B_FILE_NAME_LENGTH];
//dVolume.GetName(name);
//BDirectory rootDir;
//dVolume.GetRootDirectory(&rootDir);
//BEntry rootEntry;
//rootDir.GetEntry(&rootEntry);
//BPath rootPath;
//rootEntry.GetPath(&rootPath);
//printf("  name: `%s', root: `%s'\n", name, rootPath.Path());
                devices.insert(device);
}
//printf("GetAllDevices() done\n");
}

// IterationTest
void
VolumeTest::IterationTest()
{
        // status_t GetBootVolume(BVolume *volume)
        NextSubTest();
        BVolumeRoster roster;
        BVolume volume;
        CHK(roster.GetBootVolume(&volume) == B_OK);
        dev_t device = dev_for_path("/boot");
        CHK(device >= 0);
        CheckVolume(volume, device, B_OK);

        // status_t GetNextVolume(BVolume *volume)
        // void Rewind()
        set<dev_t> allDevices;
        GetAllDevices(allDevices);
        int32 allDevicesCount = allDevices.size();
        for (int32 i = 0; i <= allDevicesCount; i++) {
                NextSubTest();
                // iterate through the first i devices
                set<dev_t> devices(allDevices);
                volume.Unset();
                int32 checkCount = i;
                while (--checkCount >= 0 && roster.GetNextVolume(&volume) == B_OK) {
                        device = volume.Device();
                        CHK(device >= 0);
                        CheckVolume(volume, device, B_OK);
                        CHK(devices.find(device) != devices.end());
                        devices.erase(device);
                }
                // rewind and iterate through all devices
                devices = allDevices;
                roster.Rewind();
                volume.Unset();
                status_t error;
                while ((error = roster.GetNextVolume(&volume)) == B_OK) {
                        device = volume.Device();
                        CHK(device >= 0);
                        CheckVolume(volume, device, B_OK);
                        CHK(devices.find(device) != devices.end());
                        devices.erase(device);
                }
                CHK(error == B_BAD_VALUE);
                CHK(devices.empty());
                roster.Rewind();
        }

        // bad argument
// R5: crashes when passing a NULL BVolume
#ifndef TEST_R5
        NextSubTest();
        CHK(roster.GetNextVolume(NULL) == B_BAD_VALUE);
#endif
}

// CheckWatchingMessage
static
void
CheckWatchingMessage(bool mounted, dev_t expectedDevice, BTestHandler &handler,
                                         node_ref nodeRef = node_ref())
{
        snooze(100000);
        // get the message
        BMessageQueue &queue = handler.Queue();
        BMessage *_message = queue.NextMessage();
        CHK(_message);
        BMessage message(*_message);
        delete _message;
        // check the message
        if (mounted) {
                // volume mounted
                int32 opcode;
                dev_t device;
                dev_t parentDevice;
                ino_t directory;
                CHK(message.FindInt32("opcode", &opcode) == B_OK);
                CHK(message.FindInt32("new device", &device) == B_OK);
                CHK(message.FindInt32("device", &parentDevice) == B_OK);
                CHK(message.FindInt64("directory", &directory) == B_OK);
                CHK(opcode == B_DEVICE_MOUNTED);
                CHK(device == expectedDevice);
                CHK(parentDevice == nodeRef.device);
                CHK(directory == nodeRef.node);
        } else {
                // volume unmounted
                int32 opcode;
                dev_t device;
                CHK(message.FindInt32("opcode", &opcode) == B_OK);
                CHK(message.FindInt32("device", &device) == B_OK);
                CHK(opcode == B_DEVICE_UNMOUNTED);
                CHK(device == expectedDevice);
        }
}

// WatchingTest
void
VolumeTest::WatchingTest()
{
        // status_t StartWatching(BMessenger msngr=be_app_messenger);
        // void StopWatching(void);
        // BMessenger Messenger(void) const;

        // start watching
        NextSubTest();
        BVolumeRoster roster;
        CHK(!roster.Messenger().IsValid());
        BMessenger target(&fApplication->Handler());
        CHK(roster.StartWatching(target) == B_OK);
        CHK(roster.Messenger() == target);
        dev_t device = dev_for_path(testMountPoint);
        CHK(device >= 0);
        // unmount volume
        NextSubTest();
        deleteVolume(testFile1, testMountPoint, false);
        CHK(roster.Messenger() == target);
        CheckWatchingMessage(false, device, fApplication->Handler());
        // get the node_ref of the mount point
        node_ref nodeRef;
        CHK(BDirectory(testMountPoint).GetNodeRef(&nodeRef) == B_OK);
        // mount volume
        NextSubTest();
        createVolume(testFile1, testMountPoint, 1, false);
        CHK(roster.Messenger() == target);
        device = dev_for_path(testMountPoint);
        CHK(device >= 0);
        CheckWatchingMessage(true, device, fApplication->Handler(), nodeRef);
        // start watching with another target
        BTestHandler *handler2 = fApplication->CreateTestHandler();
        BMessenger target2(handler2);
        CHK(roster.StartWatching(target2) == B_OK);
        CHK(roster.Messenger() == target2);
        // unmount volume
        NextSubTest();
        deleteVolume(testFile1, testMountPoint, false);
        CHK(roster.Messenger() == target2);
        CheckWatchingMessage(false, device, *handler2);
        // mount volume
        NextSubTest();
        createVolume(testFile1, testMountPoint, 1, false);
        CHK(roster.Messenger() == target2);
        device = dev_for_path(testMountPoint);
        CHK(device >= 0);
        CheckWatchingMessage(true, device, *handler2, nodeRef);
        // stop watching
        NextSubTest();
        roster.StopWatching();
        CHK(!roster.Messenger().IsValid());
        // unmount, mount volume
        NextSubTest();
        deleteVolume(testFile1, testMountPoint, false);
        createVolume(testFile1, testMountPoint, 1, false);
        snooze(100000);
        CHK(fApplication->Handler().Queue().IsEmpty());
        CHK(handler2->Queue().IsEmpty());

        // try start watching with a bad messenger
        NextSubTest();
        CHK(roster.StartWatching(BMessenger()) == B_ERROR);
}