Reorganized test suite source tree

diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index 984ee7c7a6260f9726b8bc4d12ceea58031da68f..202695839c6312e2380576fc03f39353fff928fd 100644 (file)
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -24,5 +24,5 @@ target_link_libraries( BamTools-test BamTools BamTools-utils jsoncpp gtest )
 # add test - running 'make check' will ensure build & run
 add_test( BamToolsTest BamTools-test )
 add_custom_target( check COMMAND ${EXECUTABLE_OUTPUT_PATH}/test_bamtools
-                         DEPENDS BamTools-test )
+                         DEPENDS BamTools-test gtest )
 

diff --git a/src/test/TestMain.cpp b/src/test/TestMain.cpp
index 878e6e80e4da91deb4a2fde3a02d05635fc2d614..8d2d8611a781b573fd5cb549204813ee50a95865 100755 (executable)
--- a/src/test/TestMain.cpp
+++ b/src/test/TestMain.cpp
@@ -3,16 +3,9 @@
 #include <gtest/gtest.h>
 
 // BamTools unit tests
-#include "test/api/BamAlignment/BamAlignmentDefaultTest.h"
-#include "test/api/BamAlignment/BamAlignmentFlagTest.h"
-#include "test/api/BamAux/BamAuxBamRegionTest.h"
-#include "test/api/BamIndex/BamIndexFactoryTest.h"
-#include "test/api/BamIndex/BamStandardIndexTest.h"
-#include "test/api/BamMultiReader/BamMultiReaderFileOpsTest.h"
-#include "test/api/BamReader/BamReaderFileOpsTest.h"
-#include "test/api/SamHeader/SamHeaderValidatorTest.h"
-#include "test/api/SamHeader/SamReadGroupDictionaryTest.h"
-#include "test/api/SamHeader/SamSequenceDictionaryTest.h"
+#include "test/api/BamToolsApiTest.h"
+#include "test/toolkit/BamToolsToolkitTest.h"
+#include "test/utils/BamToolsUtilsTest.h"
 
 int main(int argc, char* argv[]) {
     ::testing::InitGoogleTest(&argc, argv);

diff --git a/src/test/api/BamAlignment/BamAlignmentDefaultTest.h b/src/test/api/BamAlignment/BamAlignmentDefaultTest.h
deleted file mode 100755 (executable)
index 6187342..0000000
--- a/src/test/api/BamAlignment/BamAlignmentDefaultTest.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef BAMALIGNMENT_DEFAULTTEST_H
-#define BAMALIGNMENT_DEFAULTTEST_H
-
-#include "api/BamAlignment.h"
-#include <gtest/gtest.h>
-
-class BamAlignment_DefaultTest : public ::testing::Test {
-    protected:
-        BamTools::BamAlignment al;
-};
-
-TEST_F(BamAlignment_DefaultTest, DefaultValues) {
-    EXPECT_EQ(-1, al.RefID);
-    EXPECT_EQ(-1, al.Position);
-    EXPECT_EQ(-1, al.MateRefID);
-    EXPECT_EQ(-1, al.MatePosition);
-    EXPECT_EQ(0,  al.InsertSize);
-}
-
-#endif // BAMALIGNMENT_DEFAULTTEST_H

diff --git a/src/test/api/BamAlignment/BamAlignmentFlagTest.h b/src/test/api/BamAlignment/BamAlignmentFlagTest.h
deleted file mode 100755 (executable)
index 5f92557..0000000
--- a/src/test/api/BamAlignment/BamAlignmentFlagTest.h
+++ /dev/null
@@ -1,89 +0,0 @@
-#ifndef BAMALIGNMENT_FLAGTEST_H
-#define BAMALIGNMENT_FLAGTEST_H
-
-#include "api/BamAlignment.h"
-#include <gtest/gtest.h>
-
-class BamAlignment_FlagTest : public ::testing::Test {
-    protected:
-        BamTools::BamAlignment al;
-};
-        
-TEST_F(BamAlignment_FlagTest, IsDuplicate) {
-    al.SetIsDuplicate(true);
-    EXPECT_TRUE(al.IsDuplicate());
-    al.SetIsDuplicate(false);
-    EXPECT_FALSE(al.IsDuplicate());
-}
-
-TEST_F(BamAlignment_FlagTest, IsFailedQC) {
-    al.SetIsFailedQC(true);
-    EXPECT_TRUE(al.IsFailedQC());
-    al.SetIsFailedQC(false);
-    EXPECT_FALSE(al.IsFailedQC());
-}
-
-TEST_F(BamAlignment_FlagTest, IsFirstMate) {
-    al.SetIsFirstMate(true);
-    EXPECT_TRUE(al.IsFirstMate());
-    al.SetIsFirstMate(false);
-    EXPECT_FALSE(al.IsFirstMate());
-}
-
-TEST_F(BamAlignment_FlagTest, IsMapped) {
-    al.SetIsMapped(true);
-    EXPECT_TRUE(al.IsMapped());
-    al.SetIsMapped(false);
-    EXPECT_FALSE(al.IsMapped());
-}
-
-TEST_F(BamAlignment_FlagTest, IsMateMapped) {
-    al.SetIsMateMapped(true);
-    EXPECT_TRUE(al.IsMateMapped());
-    al.SetIsMateMapped(false);
-    EXPECT_FALSE(al.IsMateMapped());
-}
-
-TEST_F(BamAlignment_FlagTest, IsMateReverseStrand) {
-    al.SetIsMateReverseStrand(true);
-    EXPECT_TRUE(al.IsMateReverseStrand());
-    al.SetIsMateReverseStrand(false);
-    EXPECT_FALSE(al.IsMateReverseStrand());
-}
-
-TEST_F(BamAlignment_FlagTest, IsPaired) {
-    al.SetIsPaired(true);
-    EXPECT_TRUE(al.IsPaired());
-    al.SetIsPaired(false);
-    EXPECT_FALSE(al.IsPaired());
-}
-
-TEST_F(BamAlignment_FlagTest, IsPrimaryAlignment) {
-    al.SetIsPrimaryAlignment(true);
-    EXPECT_TRUE(al.IsPrimaryAlignment());
-    al.SetIsPrimaryAlignment(false);
-    EXPECT_FALSE(al.IsPrimaryAlignment());
-}
-
-TEST_F(BamAlignment_FlagTest, IsProperPair) {
-    al.SetIsProperPair(true);
-    EXPECT_TRUE(al.IsProperPair());
-    al.SetIsProperPair(false);
-    EXPECT_FALSE(al.IsProperPair());
-}
-
-TEST_F(BamAlignment_FlagTest, IsReverseStrand) {
-    al.SetIsReverseStrand(true);
-    EXPECT_TRUE(al.IsReverseStrand());
-    al.SetIsReverseStrand(false);
-    EXPECT_FALSE(al.IsReverseStrand());
-}
-
-TEST_F(BamAlignment_FlagTest, IsSecondMate) {
-    al.SetIsSecondMate(true);
-    EXPECT_TRUE(al.IsSecondMate());
-    al.SetIsSecondMate(false);
-    EXPECT_FALSE(al.IsSecondMate());
-}  
-
-#endif // BAMALIGNMENT_FLAGTEST_H

diff --git a/src/test/api/BamAlignmentDefaultTest.h b/src/test/api/BamAlignmentDefaultTest.h
new file mode 100755 (executable)
index 0000000..6187342
--- /dev/null
+++ b/src/test/api/BamAlignmentDefaultTest.h
@@ -0,0 +1,20 @@
+#ifndef BAMALIGNMENT_DEFAULTTEST_H
+#define BAMALIGNMENT_DEFAULTTEST_H
+
+#include "api/BamAlignment.h"
+#include <gtest/gtest.h>
+
+class BamAlignment_DefaultTest : public ::testing::Test {
+    protected:
+        BamTools::BamAlignment al;
+};
+
+TEST_F(BamAlignment_DefaultTest, DefaultValues) {
+    EXPECT_EQ(-1, al.RefID);
+    EXPECT_EQ(-1, al.Position);
+    EXPECT_EQ(-1, al.MateRefID);
+    EXPECT_EQ(-1, al.MatePosition);
+    EXPECT_EQ(0,  al.InsertSize);
+}
+
+#endif // BAMALIGNMENT_DEFAULTTEST_H

diff --git a/src/test/api/BamAlignmentFlagTest.h b/src/test/api/BamAlignmentFlagTest.h
new file mode 100755 (executable)
index 0000000..5f92557
--- /dev/null
+++ b/src/test/api/BamAlignmentFlagTest.h
@@ -0,0 +1,89 @@
+#ifndef BAMALIGNMENT_FLAGTEST_H
+#define BAMALIGNMENT_FLAGTEST_H
+
+#include "api/BamAlignment.h"
+#include <gtest/gtest.h>
+
+class BamAlignment_FlagTest : public ::testing::Test {
+    protected:
+        BamTools::BamAlignment al;
+};
+        
+TEST_F(BamAlignment_FlagTest, IsDuplicate) {
+    al.SetIsDuplicate(true);
+    EXPECT_TRUE(al.IsDuplicate());
+    al.SetIsDuplicate(false);
+    EXPECT_FALSE(al.IsDuplicate());
+}
+
+TEST_F(BamAlignment_FlagTest, IsFailedQC) {
+    al.SetIsFailedQC(true);
+    EXPECT_TRUE(al.IsFailedQC());
+    al.SetIsFailedQC(false);
+    EXPECT_FALSE(al.IsFailedQC());
+}
+
+TEST_F(BamAlignment_FlagTest, IsFirstMate) {
+    al.SetIsFirstMate(true);
+    EXPECT_TRUE(al.IsFirstMate());
+    al.SetIsFirstMate(false);
+    EXPECT_FALSE(al.IsFirstMate());
+}
+
+TEST_F(BamAlignment_FlagTest, IsMapped) {
+    al.SetIsMapped(true);
+    EXPECT_TRUE(al.IsMapped());
+    al.SetIsMapped(false);
+    EXPECT_FALSE(al.IsMapped());
+}
+
+TEST_F(BamAlignment_FlagTest, IsMateMapped) {
+    al.SetIsMateMapped(true);
+    EXPECT_TRUE(al.IsMateMapped());
+    al.SetIsMateMapped(false);
+    EXPECT_FALSE(al.IsMateMapped());
+}
+
+TEST_F(BamAlignment_FlagTest, IsMateReverseStrand) {
+    al.SetIsMateReverseStrand(true);
+    EXPECT_TRUE(al.IsMateReverseStrand());
+    al.SetIsMateReverseStrand(false);
+    EXPECT_FALSE(al.IsMateReverseStrand());
+}
+
+TEST_F(BamAlignment_FlagTest, IsPaired) {
+    al.SetIsPaired(true);
+    EXPECT_TRUE(al.IsPaired());
+    al.SetIsPaired(false);
+    EXPECT_FALSE(al.IsPaired());
+}
+
+TEST_F(BamAlignment_FlagTest, IsPrimaryAlignment) {
+    al.SetIsPrimaryAlignment(true);
+    EXPECT_TRUE(al.IsPrimaryAlignment());
+    al.SetIsPrimaryAlignment(false);
+    EXPECT_FALSE(al.IsPrimaryAlignment());
+}
+
+TEST_F(BamAlignment_FlagTest, IsProperPair) {
+    al.SetIsProperPair(true);
+    EXPECT_TRUE(al.IsProperPair());
+    al.SetIsProperPair(false);
+    EXPECT_FALSE(al.IsProperPair());
+}
+
+TEST_F(BamAlignment_FlagTest, IsReverseStrand) {
+    al.SetIsReverseStrand(true);
+    EXPECT_TRUE(al.IsReverseStrand());
+    al.SetIsReverseStrand(false);
+    EXPECT_FALSE(al.IsReverseStrand());
+}
+
+TEST_F(BamAlignment_FlagTest, IsSecondMate) {
+    al.SetIsSecondMate(true);
+    EXPECT_TRUE(al.IsSecondMate());
+    al.SetIsSecondMate(false);
+    EXPECT_FALSE(al.IsSecondMate());
+}  
+
+#endif // BAMALIGNMENT_FLAGTEST_H

diff --git a/src/test/api/BamAux/BamAuxBamRegionTest.h b/src/test/api/BamAux/BamAuxBamRegionTest.h
deleted file mode 100644 (file)
index 5b6009e..0000000
--- a/src/test/api/BamAux/BamAuxBamRegionTest.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#ifndef BAMAUX_BAMREGIONTEST_H
-#define BAMAUX_BAMREGIONTEST_H
-
-#include "api/BamAux.h"
-#include <gtest/gtest.h>
-
-TEST(BamAux_BamRegionTest, DefaultValues) {
-    BamTools::BamRegion region;
-    EXPECT_EQ(-1, region.LeftRefID);
-    EXPECT_EQ(-1, region.LeftPosition);
-    EXPECT_EQ(-1, region.RightRefID);
-    EXPECT_EQ(-1, region.RightPosition);
-}
-
-TEST(BamAux_BamRegionTest, IsNull) {
-    
-    BamTools::BamRegion empty;
-    EXPECT_TRUE(empty.isNull());
-
-    BamTools::BamRegion normal(1,100,2,200);
-    EXPECT_FALSE(normal.isNull());
-}
-
-TEST(BamAux_BamRegionTest, Clear) {
-
-    BamTools::BamRegion region(1,100);
-    EXPECT_FALSE(region.isNull());
-    region.clear();
-    EXPECT_TRUE(region.isNull());
-}
-
-TEST(BamAux_BamRegionTest, IsLeftBoundSpecified) {
-
-    // no left bound
-    BamTools::BamRegion empty;
-    EXPECT_FALSE(empty.isLeftBoundSpecified());
-
-    // regular left bound
-    BamTools::BamRegion region(1, 100);
-    EXPECT_TRUE(region.isLeftBoundSpecified());
-
-    // invalid left bound
-    BamTools::BamRegion invalidID(-2);
-    EXPECT_FALSE(invalidID.isLeftBoundSpecified());
-    BamTools::BamRegion invalidPosition(1, -200);
-    EXPECT_FALSE(invalidPosition.isLeftBoundSpecified());
-}
-
-#endif // BAMAUX_BAMREGIONTEST_H

diff --git a/src/test/api/BamIndex/BamIndexFactoryTest.h b/src/test/api/BamIndex/BamIndexFactoryTest.h
deleted file mode 100644 (file)
index f6755df..0000000
--- a/src/test/api/BamIndex/BamIndexFactoryTest.h
+++ /dev/null
@@ -1,89 +0,0 @@
-#ifndef BAMINDEX_FACTORYTEST_H
-#define BAMINDEX_FACTORYTEST_H
-
-#include "api/BamIndex.h"
-#include "api/internal/index/BamIndexFactory_p.h"
-#include "api/internal/index/BamStandardIndex_p.h"
-#include "api/internal/index/BamToolsIndex_p.h"
-
-#include <gtest/gtest.h>
-#include <iostream>
-#include <string>
-
-TEST(BamIndex_FactoryTest, CreateIndexFilename) {
-
-    const std::string bamFilename      = "dummy.bam";
-    const std::string baiIndexFilename = BamTools::Internal::BamIndexFactory::CreateIndexFilename(bamFilename, BamTools::BamIndex::STANDARD);
-    const std::string btiIndexFilename = BamTools::Internal::BamIndexFactory::CreateIndexFilename(bamFilename, BamTools::BamIndex::BAMTOOLS);
-
-    EXPECT_EQ("dummy.bam.bai", baiIndexFilename);
-    EXPECT_EQ("dummy.bam.bti", btiIndexFilename);
-}
-
-TEST(BamIndex_FactoryTest, FileExtension) {
-
-    const std::string bamFilename      = "dummy.bam";
-    const std::string baiIndexFilename = "dummy.bam.bai";
-    const std::string btiIndexFilename = "path/to/dummy.bam.bti";
-
-    const std::string bamExtension = BamTools::Internal::BamIndexFactory::FileExtension(bamFilename);
-    const std::string baiExtension = BamTools::Internal::BamIndexFactory::FileExtension(baiIndexFilename);
-    const std::string btiExtension = BamTools::Internal::BamIndexFactory::FileExtension(btiIndexFilename);
-
-    EXPECT_EQ(".bam", bamExtension);
-    EXPECT_EQ(".bai", baiExtension);
-    EXPECT_EQ(".bti", btiExtension);
-
-    // TODO: try some invalid values, just to make sure this is robust/safe enough
-}
-
-TEST(BamIndex_FactoryTest, CreateIndexFromFilename) {
-
-    const std::string baiIndexFilename = "../data/ex1.bam.bai";
-    const std::string btiIndexFilename = "../data/ex1.bam.bti";
-
-    BamTools::BamIndex* bai = BamTools::Internal::BamIndexFactory::CreateIndexFromFilename(baiIndexFilename, 0);
-    BamTools::BamIndex* bti = BamTools::Internal::BamIndexFactory::CreateIndexFromFilename(btiIndexFilename, 0);
-
-    ASSERT_TRUE(bai != NULL);
-    ASSERT_TRUE(bti != NULL);
-
-    EXPECT_EQ(BamTools::BamIndex::STANDARD, bai->Type());
-    EXPECT_EQ(BamTools::BamIndex::BAMTOOLS, bti->Type());
-
-    delete bai;
-    delete bti;
-
-    std::cerr << "TestMessage 4" << std::endl;
-}
-
-TEST(BamIndex_FactoryTest, CreateIndexOfType) {
-
-    BamTools::BamIndex* bai = BamTools::Internal::BamIndexFactory::CreateIndexOfType(BamTools::BamIndex::STANDARD, 0);
-    BamTools::BamIndex* bti = BamTools::Internal::BamIndexFactory::CreateIndexOfType(BamTools::BamIndex::BAMTOOLS, 0);
-
-    EXPECT_EQ(BamTools::BamIndex::STANDARD, bai->Type());
-    EXPECT_EQ(BamTools::BamIndex::BAMTOOLS, bti->Type());
-
-    delete bai;
-    delete bti;
-}
-
-TEST(BamIndex_FactoryTest, FindIndexFilename) {
-
-    // Both BAI & BTI are available
-    const std::string bamFilename = "../data/ex1.bam";
-    const std::string baiIndexFilename = BamTools::Internal::BamIndexFactory::FindIndexFilename(bamFilename, BamTools::BamIndex::STANDARD);
-    const std::string btiIndexFilename = BamTools::Internal::BamIndexFactory::FindIndexFilename(bamFilename, BamTools::BamIndex::BAMTOOLS);
-    EXPECT_EQ("../data/ex1.bam.bai", baiIndexFilename);
-    EXPECT_EQ("../data/ex1.bam.bti", btiIndexFilename);
-
-    // No BTI index available, both requests should fall back to BAI
-    const std::string bamFilename2 = "../data/BCM.ceph.chr20.bam";
-    const std::string baiIndexFilename2 = BamTools::Internal::BamIndexFactory::FindIndexFilename(bamFilename2, BamTools::BamIndex::STANDARD);
-    const std::string btiIndexFilename2 = BamTools::Internal::BamIndexFactory::FindIndexFilename(bamFilename2, BamTools::BamIndex::BAMTOOLS);
-    EXPECT_EQ("../data/BCM.ceph.chr20.bam.bai", baiIndexFilename2);
-    EXPECT_EQ("../data/BCM.ceph.chr20.bam.bai", btiIndexFilename2);
-}
-
-#endif // BAMINDEX_FACTORYTEST_H

diff --git a/src/test/api/BamIndex/BamStandardIndexTest.h b/src/test/api/BamIndex/BamStandardIndexTest.h
deleted file mode 100644 (file)
index ca1aadd..0000000
--- a/src/test/api/BamIndex/BamStandardIndexTest.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef BAMSTANDARDINDEX_TEST_H
-#define BAMSTANDARDINDEX_TEST_H
-
-#include <gtest/gtest.h>
-#include "api/internal/index/BamStandardIndex_p.h"
-
-TEST(BamStandardIndexTest, Open) {
-
-
-
-}
-
-#endif // BAMSTANDARDINDEX_TEST_H

diff --git a/src/test/api/BamIndex/BamToolsIndexTest.h b/src/test/api/BamIndex/BamToolsIndexTest.h
deleted file mode 100644 (file)
index e69de29..0000000

diff --git a/src/test/api/BamMultiReader/BamMultiReaderFileOpsTest.h b/src/test/api/BamMultiReader/BamMultiReaderFileOpsTest.h
deleted file mode 100644 (file)
index aba2b7c..0000000
--- a/src/test/api/BamMultiReader/BamMultiReaderFileOpsTest.h
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef BAMMULTIREADER_FILEOPSTEST_H
-#define BAMMULTIREADER_FILEOPSTEST_H
-
-#include "api/BamMultiReader.h"
-#include <gtest/gtest.h>
-
-#include <iostream>
-#include <string>
-#include <vector>
-
-TEST(BamMultiReaderFileOpsTest, Defaults) {
-
-    BamTools::BamMultiReader reader;
-
-    EXPECT_FALSE(reader.HasOpenReaders());
-    EXPECT_FALSE(reader.HasIndexes());
-    std::vector<std::string> filenames = reader.Filenames();
-    EXPECT_EQ(0, (int)filenames.size());
-    EXPECT_EQ("", reader.GetHeaderText());
-    EXPECT_EQ(0, reader.GetReferenceCount());
-}
-
-TEST(BamMultiReaderFileOpsTest, NonExistentFiles) {
-
-    std::vector<std::string> inputFiles;
-    inputFiles.push_back("../data/fake.bam");
-    inputFiles.push_back("../data/fake2.bam");
-
-    BamTools::BamMultiReader reader;
-    EXPECT_FALSE(reader.Open(inputFiles));
-
-    EXPECT_FALSE(reader.HasOpenReaders());
-    EXPECT_FALSE(reader.HasIndexes());
-    std::vector<std::string> filenames = reader.Filenames();
-    EXPECT_EQ(0, (int)filenames.size());
-    EXPECT_EQ("", reader.GetHeaderText());
-    EXPECT_EQ(0, reader.GetReferenceCount());
-}
-
-TEST(BamMultiReaderFileOpsTest, EmptyFiles) {
-
-    std::vector<std::string> inputFiles;
-    inputFiles.push_back("../data/empty.bam");
-    inputFiles.push_back("../data/empty1.bam");
-    inputFiles.push_back("../data/empty2.bam");
-
-    BamTools::BamMultiReader reader;
-    EXPECT_FALSE(reader.Open(inputFiles));
-
-    EXPECT_FALSE(reader.HasOpenReaders());
-    EXPECT_FALSE(reader.HasIndexes());
-    std::vector<std::string> filenames = reader.Filenames();
-    EXPECT_EQ(0, (int)filenames.size());
-    EXPECT_EQ("", reader.GetHeaderText());
-    EXPECT_EQ(0, reader.GetReferenceCount());
-}
-
-#endif // BAMMULTIREADER_FILEOPSTEST_H

diff --git a/src/test/api/BamMultiReaderFileOpsTest.h b/src/test/api/BamMultiReaderFileOpsTest.h
new file mode 100644 (file)
index 0000000..aba2b7c
--- /dev/null
+++ b/src/test/api/BamMultiReaderFileOpsTest.h
@@ -0,0 +1,58 @@
+#ifndef BAMMULTIREADER_FILEOPSTEST_H
+#define BAMMULTIREADER_FILEOPSTEST_H
+
+#include "api/BamMultiReader.h"
+#include <gtest/gtest.h>
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+TEST(BamMultiReaderFileOpsTest, Defaults) {
+
+    BamTools::BamMultiReader reader;
+
+    EXPECT_FALSE(reader.HasOpenReaders());
+    EXPECT_FALSE(reader.HasIndexes());
+    std::vector<std::string> filenames = reader.Filenames();
+    EXPECT_EQ(0, (int)filenames.size());
+    EXPECT_EQ("", reader.GetHeaderText());
+    EXPECT_EQ(0, reader.GetReferenceCount());
+}
+
+TEST(BamMultiReaderFileOpsTest, NonExistentFiles) {
+
+    std::vector<std::string> inputFiles;
+    inputFiles.push_back("../data/fake.bam");
+    inputFiles.push_back("../data/fake2.bam");
+
+    BamTools::BamMultiReader reader;
+    EXPECT_FALSE(reader.Open(inputFiles));
+
+    EXPECT_FALSE(reader.HasOpenReaders());
+    EXPECT_FALSE(reader.HasIndexes());
+    std::vector<std::string> filenames = reader.Filenames();
+    EXPECT_EQ(0, (int)filenames.size());
+    EXPECT_EQ("", reader.GetHeaderText());
+    EXPECT_EQ(0, reader.GetReferenceCount());
+}
+
+TEST(BamMultiReaderFileOpsTest, EmptyFiles) {
+
+    std::vector<std::string> inputFiles;
+    inputFiles.push_back("../data/empty.bam");
+    inputFiles.push_back("../data/empty1.bam");
+    inputFiles.push_back("../data/empty2.bam");
+
+    BamTools::BamMultiReader reader;
+    EXPECT_FALSE(reader.Open(inputFiles));
+
+    EXPECT_FALSE(reader.HasOpenReaders());
+    EXPECT_FALSE(reader.HasIndexes());
+    std::vector<std::string> filenames = reader.Filenames();
+    EXPECT_EQ(0, (int)filenames.size());
+    EXPECT_EQ("", reader.GetHeaderText());
+    EXPECT_EQ(0, reader.GetReferenceCount());
+}
+
+#endif // BAMMULTIREADER_FILEOPSTEST_H

diff --git a/src/test/api/BamReader/BamReaderFileOpsTest.h b/src/test/api/BamReader/BamReaderFileOpsTest.h
deleted file mode 100644 (file)
index 8c574e2..0000000
--- a/src/test/api/BamReader/BamReaderFileOpsTest.h
+++ /dev/null
@@ -1,73 +0,0 @@
-#ifndef BAMREADER_FILEOPSTEST_H
-#define BAMREADER_FILEOPSTEST_H
-
-#include "api/BamReader.h"
-#include <gtest/gtest.h>
-
-TEST(BamReaderFileOpsTest, Defaults) {
-
-    BamTools::BamReader reader;
-    EXPECT_FALSE(reader.IsOpen());
-    EXPECT_FALSE(reader.HasIndex());
-    EXPECT_EQ("", reader.GetFilename());
-    EXPECT_EQ("", reader.GetHeaderText());
-    EXPECT_EQ(0,  reader.GetReferenceCount());
-}
-
-TEST(BamReaderFileOpsTest, NonExistentFile) {
-
-    BamTools::BamReader reader;
-    EXPECT_FALSE(reader.Open("../data/fake.bam"));
-
-    EXPECT_FALSE(reader.IsOpen());
-    EXPECT_FALSE(reader.HasIndex());
-    EXPECT_EQ("", reader.GetFilename());
-    EXPECT_EQ("", reader.GetHeaderText());
-    EXPECT_EQ(0,  reader.GetReferenceCount());
-}
-
-TEST(BamReaderFileOpsTest, EmptyFile) {
-
-    BamTools::BamReader reader;
-    EXPECT_FALSE(reader.Open("../data/empty.bam"));
-
-    EXPECT_FALSE(reader.IsOpen());
-    EXPECT_FALSE(reader.HasIndex());
-    EXPECT_EQ("", reader.GetFilename());
-    EXPECT_EQ("", reader.GetHeaderText());
-    EXPECT_EQ(0,  reader.GetReferenceCount());
-}
-
-TEST(BamReaderFileOpsTest, NormalFile_NoIndexNoHeader) {
-
-    BamTools::BamReader reader;
-    EXPECT_TRUE(reader.Open("../data/ex1.bam"));
-
-    EXPECT_TRUE(reader.IsOpen());
-    EXPECT_FALSE(reader.HasIndex());
-    EXPECT_EQ("../data/ex1.bam", reader.GetFilename());
-    EXPECT_EQ("", reader.GetHeaderText());
-    EXPECT_EQ(2,  reader.GetReferenceCount());
-}
-
-TEST(BamReaderFileOpsTest, NormalFile_ExplicitIndexFilename) {
-
-    BamTools::BamReader reader;
-    EXPECT_TRUE(reader.Open("../data/ex1.bam"));
-
-    EXPECT_TRUE(reader.IsOpen());
-    EXPECT_FALSE(reader.HasIndex());
-    EXPECT_EQ("../data/ex1.bam", reader.GetFilename());
-    EXPECT_EQ("", reader.GetHeaderText());
-    EXPECT_EQ(2,  reader.GetReferenceCount());
-
-    EXPECT_TRUE(reader.OpenIndex("../data/ex1.bam.bai"));
-
-    EXPECT_TRUE(reader.IsOpen());
-    EXPECT_TRUE(reader.HasIndex());
-    EXPECT_EQ("../data/ex1.bam", reader.GetFilename());
-    EXPECT_EQ("", reader.GetHeaderText());
-    EXPECT_EQ(2,  reader.GetReferenceCount());
-}
-
-#endif // BAMREADER_FILEOPSTEST_H

diff --git a/src/test/api/BamReaderFileOpsTest.h b/src/test/api/BamReaderFileOpsTest.h
new file mode 100644 (file)
index 0000000..8c574e2
--- /dev/null
+++ b/src/test/api/BamReaderFileOpsTest.h
@@ -0,0 +1,73 @@
+#ifndef BAMREADER_FILEOPSTEST_H
+#define BAMREADER_FILEOPSTEST_H
+
+#include "api/BamReader.h"
+#include <gtest/gtest.h>
+
+TEST(BamReaderFileOpsTest, Defaults) {
+
+    BamTools::BamReader reader;
+    EXPECT_FALSE(reader.IsOpen());
+    EXPECT_FALSE(reader.HasIndex());
+    EXPECT_EQ("", reader.GetFilename());
+    EXPECT_EQ("", reader.GetHeaderText());
+    EXPECT_EQ(0,  reader.GetReferenceCount());
+}
+
+TEST(BamReaderFileOpsTest, NonExistentFile) {
+
+    BamTools::BamReader reader;
+    EXPECT_FALSE(reader.Open("../data/fake.bam"));
+
+    EXPECT_FALSE(reader.IsOpen());
+    EXPECT_FALSE(reader.HasIndex());
+    EXPECT_EQ("", reader.GetFilename());
+    EXPECT_EQ("", reader.GetHeaderText());
+    EXPECT_EQ(0,  reader.GetReferenceCount());
+}
+
+TEST(BamReaderFileOpsTest, EmptyFile) {
+
+    BamTools::BamReader reader;
+    EXPECT_FALSE(reader.Open("../data/empty.bam"));
+
+    EXPECT_FALSE(reader.IsOpen());
+    EXPECT_FALSE(reader.HasIndex());
+    EXPECT_EQ("", reader.GetFilename());
+    EXPECT_EQ("", reader.GetHeaderText());
+    EXPECT_EQ(0,  reader.GetReferenceCount());
+}
+
+TEST(BamReaderFileOpsTest, NormalFile_NoIndexNoHeader) {
+
+    BamTools::BamReader reader;
+    EXPECT_TRUE(reader.Open("../data/ex1.bam"));
+
+    EXPECT_TRUE(reader.IsOpen());
+    EXPECT_FALSE(reader.HasIndex());
+    EXPECT_EQ("../data/ex1.bam", reader.GetFilename());
+    EXPECT_EQ("", reader.GetHeaderText());
+    EXPECT_EQ(2,  reader.GetReferenceCount());
+}
+
+TEST(BamReaderFileOpsTest, NormalFile_ExplicitIndexFilename) {
+
+    BamTools::BamReader reader;
+    EXPECT_TRUE(reader.Open("../data/ex1.bam"));
+
+    EXPECT_TRUE(reader.IsOpen());
+    EXPECT_FALSE(reader.HasIndex());
+    EXPECT_EQ("../data/ex1.bam", reader.GetFilename());
+    EXPECT_EQ("", reader.GetHeaderText());
+    EXPECT_EQ(2,  reader.GetReferenceCount());
+
+    EXPECT_TRUE(reader.OpenIndex("../data/ex1.bam.bai"));
+
+    EXPECT_TRUE(reader.IsOpen());
+    EXPECT_TRUE(reader.HasIndex());
+    EXPECT_EQ("../data/ex1.bam", reader.GetFilename());
+    EXPECT_EQ("", reader.GetHeaderText());
+    EXPECT_EQ(2,  reader.GetReferenceCount());
+}
+
+#endif // BAMREADER_FILEOPSTEST_H

diff --git a/src/test/api/BamRegionTest.h b/src/test/api/BamRegionTest.h
new file mode 100644 (file)
index 0000000..5b6009e
--- /dev/null
+++ b/src/test/api/BamRegionTest.h
@@ -0,0 +1,49 @@
+#ifndef BAMAUX_BAMREGIONTEST_H
+#define BAMAUX_BAMREGIONTEST_H
+
+#include "api/BamAux.h"
+#include <gtest/gtest.h>
+
+TEST(BamAux_BamRegionTest, DefaultValues) {
+    BamTools::BamRegion region;
+    EXPECT_EQ(-1, region.LeftRefID);
+    EXPECT_EQ(-1, region.LeftPosition);
+    EXPECT_EQ(-1, region.RightRefID);
+    EXPECT_EQ(-1, region.RightPosition);
+}
+
+TEST(BamAux_BamRegionTest, IsNull) {
+    
+    BamTools::BamRegion empty;
+    EXPECT_TRUE(empty.isNull());
+
+    BamTools::BamRegion normal(1,100,2,200);
+    EXPECT_FALSE(normal.isNull());
+}
+
+TEST(BamAux_BamRegionTest, Clear) {
+
+    BamTools::BamRegion region(1,100);
+    EXPECT_FALSE(region.isNull());
+    region.clear();
+    EXPECT_TRUE(region.isNull());
+}
+
+TEST(BamAux_BamRegionTest, IsLeftBoundSpecified) {
+
+    // no left bound
+    BamTools::BamRegion empty;
+    EXPECT_FALSE(empty.isLeftBoundSpecified());
+
+    // regular left bound
+    BamTools::BamRegion region(1, 100);
+    EXPECT_TRUE(region.isLeftBoundSpecified());
+
+    // invalid left bound
+    BamTools::BamRegion invalidID(-2);
+    EXPECT_FALSE(invalidID.isLeftBoundSpecified());
+    BamTools::BamRegion invalidPosition(1, -200);
+    EXPECT_FALSE(invalidPosition.isLeftBoundSpecified());
+}
+
+#endif // BAMAUX_BAMREGIONTEST_H

diff --git a/src/test/api/BamToolsApiTest.h b/src/test/api/BamToolsApiTest.h
new file mode 100644 (file)
index 0000000..a7ba5ae
--- /dev/null
+++ b/src/test/api/BamToolsApiTest.h
@@ -0,0 +1,28 @@
+#ifndef BAMTOOLS_TEST_API_H
+#define BAMTOOLS_TEST_API_H
+
+// general API behavior
+#include "BamAlignmentDefaultTest.h"
+#include "BamAlignmentFlagTest.h"
+#include "BamMultiReaderFileOpsTest.h"
+#include "BamReaderFileOpsTest.h"
+#include "BamRegionTest.h"
+#include "SamHeaderValidationTest.h"
+#include "SamReadGroupDictionaryTest.h"
+#include "SamSequenceDictionaryTest.h"
+
+// internal BAM behavior
+
+// internal indexing behavior
+#include "internal/index/BamIndexFactoryTest.h"
+#include "internal/index/BamStandardIndexTest.h"
+#include "internal/index/BamToolsIndexTest.h"
+
+// internal I/O behavior
+
+// internal SAM behavior
+
+// internal utils behavior
+
+#endif // BAMTOOLS_TEST_API_H
+

diff --git a/src/test/api/SamHeader/SamHeaderValidatorTest.h b/src/test/api/SamHeader/SamHeaderValidatorTest.h
deleted file mode 100644 (file)
index bec004a..0000000
--- a/src/test/api/SamHeader/SamHeaderValidatorTest.h
+++ /dev/null
@@ -1,292 +0,0 @@
-#ifndef SAMHEADER_VALIDATORTEST_H
-#define SAMHEADER_VALIDATORTEST_H
-
-#include "api/SamHeader.h"
-#include <gtest/gtest.h>
-#include <iostream>
-#include <string>
-
-TEST(SamHeader_ValidatorTest, EmptyHeader) {
-
-    BamTools::SamHeader header("");
-    std::string headerText = header.ToString();
-    ASSERT_TRUE(headerText.empty());
-    EXPECT_TRUE(header.IsValid());
-}
-
-TEST(SamHeader_ValidatorTest, Version) {
-
-    BamTools::SamHeader header("");
-
-    // empty - VALID HEADER
-    header.Version = "";
-    EXPECT_TRUE(header.IsValid());
-
-    // normal - VALID HEADER
-    header.Version = "1.1";
-    EXPECT_TRUE(header.IsValid());
-    header.Version = "11.1";
-    EXPECT_TRUE(header.IsValid());
-    header.Version = "1.11";
-
-    // no period - INVALID HEADER
-    header.Version = "11";
-    EXPECT_FALSE(header.IsValid());
-
-    // no major - INVALID HEADER
-    header.Version = ".1";
-    EXPECT_FALSE(header.IsValid());
-
-    // invalid major - INVALID HEADER
-    header.Version = "a.1";
-    EXPECT_FALSE(header.IsValid());
-
-    // no minor - INVALID HEADER
-    header.Version = "1.";
-    EXPECT_FALSE(header.IsValid());
-
-    // invalid minor - INVALID HEADER
-    header.Version = "1.a";
-    EXPECT_FALSE(header.IsValid());
-}
-
-TEST(SamHeader_ValidatorTest, GroupOrder) {
-
-    BamTools::SamHeader header("");
-
-    // empty - VALID HEADER
-    header.GroupOrder = "";
-    EXPECT_TRUE(header.IsValid());
-
-    // normal group order- VALID HEADER
-    header.GroupOrder = "none";
-    EXPECT_TRUE(header.IsValid());
-    header.GroupOrder = "query";
-    EXPECT_TRUE(header.IsValid());
-    header.GroupOrder = "reference";
-    EXPECT_TRUE(header.IsValid());
-
-    // invalid group order - INVALID HEADER
-    header.GroupOrder = "fake";
-    EXPECT_FALSE(header.IsValid());
-}
-
-TEST(SamHeader_ValidatorTest, SortOrder) {
-
-    BamTools::SamHeader header("");
-
-    // empty - VALID HEADER
-    header.SortOrder = "";
-    EXPECT_TRUE(header.IsValid());
-
-    // normal sort order- VALID HEADER
-    header.SortOrder = "coordinate";
-    EXPECT_TRUE(header.IsValid());
-    header.SortOrder = "queryname";
-    EXPECT_TRUE(header.IsValid());
-    header.SortOrder = "unsorted";
-    EXPECT_TRUE(header.IsValid());
-
-    // invalid sort order - INVALID HEADER
-    header.SortOrder = "fake";
-    EXPECT_FALSE(header.IsValid());
-}
-
-TEST(SamHeader_ValidatorTest, SequenceDictionary) {
-
-    BamTools::SamHeader header("");
-    BamTools::SamSequence sequence;
-
-    // --------------------------------
-    // empty - VALID HEADER
-
-    header.Sequences.Clear();
-    EXPECT_TRUE(header.IsValid());
-
-    // --------------------------------
-    // normal - VALID HEADER
-
-    sequence.Name   = "MT";
-    sequence.Length = "1000";
-    header.Sequences.Add(sequence);
-    EXPECT_TRUE(header.IsValid());
-
-    // normal ( length == MIN )
-    sequence.Name   = "MT";
-    sequence.Length = "1";
-    header.Sequences.Clear();
-    header.Sequences.Add(sequence);
-    EXPECT_TRUE(header.IsValid());
-
-    // normal ( length == MAX )
-    sequence.Name = "MT";
-    sequence.Length = "536870911";
-    header.Sequences.Clear();
-    header.Sequences.Add(sequence);
-    EXPECT_TRUE(header.IsValid());
-
-    // ---------------------------------
-    // missing required info - INVALID HEADER
-
-    // missing ID
-    sequence.Name = "";
-    sequence.Length = "1000";
-    header.Sequences.Clear();
-    header.Sequences.Add(sequence);
-    EXPECT_FALSE(header.IsValid());
-
-    // missing length
-    sequence.Name = "MT";
-    sequence.Length = "";
-    header.Sequences.Clear();
-    header.Sequences.Add(sequence);
-    EXPECT_FALSE(header.IsValid());
-
-    // -------------------------------------
-    // improper SN format - INVALID HEADER
-
-    // starts with *
-    sequence.Name = "*MT";
-    sequence.Length = "1000";
-    header.Sequences.Clear();
-    header.Sequences.Add(sequence);
-    EXPECT_FALSE(header.IsValid());
-
-    // starts with =
-    sequence.Name = "=MT";
-    sequence.Length = "1000";
-    header.Sequences.Clear();
-    header.Sequences.Add(sequence);
-    EXPECT_FALSE(header.IsValid());
-
-    // -----------------------------------------
-    // nonunique ID - INVALID HEADER
-
-    // this behavior is blocked by SamSequenceDictionary
-    // see SamSequenceDictionaryTest::AddDuplicateOk
-
-    // --------------------------------------------
-    // invalid length  - INVALID HEADER
-
-    // length = 0 (MIN == 1)
-    sequence.Name = "MT";
-    sequence.Length = "0";
-    header.Sequences.Clear();
-    header.Sequences.Add(sequence);
-    EXPECT_FALSE(header.IsValid());
-
-    // length = -1
-    sequence.Name = "MT";
-    sequence.Length = "-1";
-    header.Sequences.Clear();
-    header.Sequences.Add(sequence);
-    EXPECT_FALSE(header.IsValid());
-
-    // length = MAX + 1
-    sequence.Name ="MT";
-    sequence.Length = "536870912";
-    header.Sequences.Clear();
-    header.Sequences.Add(sequence);
-    EXPECT_FALSE(header.IsValid());
-}
-
-TEST(SamHeader_ValidatorTest, ReadGroupDictionary) {
-
-    BamTools::SamHeader header("");
-    BamTools::SamReadGroup readGroup;
-
-    // ---------------------------------
-    // empty - VALID HEADER
-
-    header.ReadGroups.Clear();
-    EXPECT_TRUE(header.IsValid());
-
-    // ---------------------------------
-    // normal - VALID HEADER
-
-    readGroup.ID = "Group123";
-    readGroup.PlatformUnit = "PU001";
-
-    // technology: none
-    header.ReadGroups.Clear();
-    header.ReadGroups.Add(readGroup);
-    EXPECT_TRUE(header.IsValid());
-
-    // technology: capillary
-    readGroup.SequencingTechnology = "CAPILLARY";
-    header.ReadGroups.Clear();
-    header.ReadGroups.Add(readGroup);
-    EXPECT_TRUE(header.IsValid());
-
-    // technology: Helicos
-    readGroup.SequencingTechnology = "HELICOS";
-    header.ReadGroups.Clear();
-    header.ReadGroups.Add(readGroup);
-    EXPECT_TRUE(header.IsValid());
-
-    // technology: Illumina
-    readGroup.SequencingTechnology = "ILLUMINA";
-    header.ReadGroups.Clear();
-    header.ReadGroups.Add(readGroup);
-    EXPECT_TRUE(header.IsValid());
-
-    // technology: IonTorrent
-    readGroup.SequencingTechnology = "IONTORRENT";
-    header.ReadGroups.Clear();
-    header.ReadGroups.Add(readGroup);
-    EXPECT_TRUE(header.IsValid());
-
-    // technology: 454
-    readGroup.SequencingTechnology = "LS454";
-    header.ReadGroups.Clear();
-    header.ReadGroups.Add(readGroup);
-    EXPECT_TRUE(header.IsValid());
-
-    // technology: Pacific Bio
-    readGroup.SequencingTechnology = "PACBIO";
-    header.ReadGroups.Clear();
-    header.ReadGroups.Add(readGroup);
-    EXPECT_TRUE(header.IsValid());
-
-    // technology: Solid
-    readGroup.SequencingTechnology = "SOLID";
-    header.ReadGroups.Clear();
-    header.ReadGroups.Add(readGroup);
-    EXPECT_TRUE(header.IsValid());
-
-    // ---------------------------------
-    // missing ID - INVALID HEADER
-
-    readGroup.ID = "";
-    header.ReadGroups.Clear();
-    header.ReadGroups.Add(readGroup);
-    EXPECT_FALSE(header.IsValid());
-
-    // -----------------------------------------
-    // nonunique ID - INVALID HEADER
-
-    // this behavior is blocked by SamReadGroupDictionary
-    // see SamReadGroupDictionaryTest::AddDuplicateOk
-
-    // ------------------------------------------
-    // nonunique platform unit - INVALID HEADER
-
-    BamTools::SamReadGroup dupPU("Group1");
-    BamTools::SamReadGroup dupPU2("Group2");
-    dupPU.PlatformUnit = "PU001";
-    dupPU2.PlatformUnit = "PU001";
-    header.ReadGroups.Clear();
-    header.ReadGroups.Add(dupPU);
-    header.ReadGroups.Add(dupPU2);
-    EXPECT_FALSE(header.IsValid());
-
-    // ------------------------------------------------
-    // invalid sequencing technology - INVALID HEADER
-
-    readGroup.SequencingTechnology = "fake";
-    header.ReadGroups.Clear();
-    header.ReadGroups.Add(readGroup);
-    EXPECT_FALSE(header.IsValid());
-}
-
-#endif // SAMHEADER_VALIDATORTEST_H

diff --git a/src/test/api/SamHeader/SamReadGroupDictionaryTest.h b/src/test/api/SamHeader/SamReadGroupDictionaryTest.h
deleted file mode 100644 (file)
index ccf8d89..0000000
--- a/src/test/api/SamHeader/SamReadGroupDictionaryTest.h
+++ /dev/null
@@ -1,68 +0,0 @@
-#ifndef SAMREADGROUPDICTIONARY_TEST_H
-#define SAMREADGROUPDICTIONARY_TEST_H
-
-#include "api/SamReadGroupDictionary.h"
-#include <gtest/gtest.h>
-#include <vector>
-
-TEST(SamReadGroupDictionaryTest, Empty) {
-    BamTools::SamReadGroupDictionary readGroups;
-    EXPECT_TRUE(readGroups.IsEmpty());
-    EXPECT_EQ(0, readGroups.Size());
-}
-
-TEST(SamReadGroupDictionaryTest, AddOne) {
-
-    BamTools::SamReadGroupDictionary readGroups;
-    readGroups.Add(BamTools::SamReadGroup());
-    EXPECT_FALSE(readGroups.IsEmpty());
-    EXPECT_EQ(1, readGroups.Size());
-}
-
-TEST(SamReadGroupDictionaryTest, AddMulti) {
-
-    std::vector<BamTools::SamReadGroup> groups;
-    groups.push_back(BamTools::SamReadGroup("1"));
-    groups.push_back(BamTools::SamReadGroup("2"));
-
-    BamTools::SamReadGroupDictionary readGroups;
-    readGroups.Add(groups);
-    EXPECT_FALSE(readGroups.IsEmpty());
-    EXPECT_EQ(2, readGroups.Size());
-}
-
-TEST(SamReadGroupDictionaryTest, AddDuplicate) {
-
-    std::vector<BamTools::SamReadGroup> groups;
-    groups.push_back(BamTools::SamReadGroup("1"));
-    groups.push_back(BamTools::SamReadGroup("1"));
-
-    // add duplicates through Add()
-    BamTools::SamReadGroupDictionary readGroups;
-    readGroups.Add(groups);
-    EXPECT_FALSE(readGroups.IsEmpty());
-    EXPECT_EQ(1, readGroups.Size());    // duplicate should not get added
-
-    // add duplicates through operator[]
-    readGroups.Clear();
-    readGroups["1"] = groups.at(0);
-    readGroups["1"] = groups.at(0);
-    EXPECT_FALSE(readGroups.IsEmpty());
-    EXPECT_EQ(1, readGroups.Size());     // duplicate should not get added
-}
-
-TEST(SamReadGroupDictionaryTest, Clear) {
-
-    // add a read group
-    BamTools::SamReadGroupDictionary readGroups;
-    readGroups.Add(BamTools::SamReadGroup());
-    EXPECT_FALSE(readGroups.IsEmpty());
-    EXPECT_EQ(1, readGroups.Size());;
-
-    // test clear
-    readGroups.Clear();
-    EXPECT_TRUE(readGroups.IsEmpty());
-    EXPECT_EQ(0, readGroups.Size());
-}
-
-#endif // SAMREADGROUPDICTIONARY_TEST_H

diff --git a/src/test/api/SamHeader/SamSequenceDictionaryTest.h b/src/test/api/SamHeader/SamSequenceDictionaryTest.h
deleted file mode 100644 (file)
index bd75e1e..0000000
--- a/src/test/api/SamHeader/SamSequenceDictionaryTest.h
+++ /dev/null
@@ -1,69 +0,0 @@
-#ifndef SAMSEQUENCEDICTIONARY_TEST_H
-#define SAMSEQUENCEDICTIONARY_TEST_H
-
-#include "api/SamSequenceDictionary.h"
-#include <gtest/gtest.h>
-#include <vector>
-
-TEST(SamSequenceDictionaryTest, Empty) {
-
-    BamTools::SamSequenceDictionary sequences;
-    EXPECT_TRUE(sequences.IsEmpty());
-    EXPECT_EQ(0, sequences.Size());
-}
-
-TEST(SamSequenceDictionaryTest, AddOne) {
-
-    BamTools::SamSequenceDictionary sequences;
-    sequences.Add(BamTools::SamSequence());
-    EXPECT_FALSE(sequences.IsEmpty());
-    EXPECT_EQ(1, sequences.Size());
-}
-
-TEST(SamSequenceDictionaryTest, AddMulti) {
-
-    std::vector<BamTools::SamSequence> groups;
-    groups.push_back(BamTools::SamSequence("1", 100));
-    groups.push_back(BamTools::SamSequence("2", 100));
-
-    BamTools::SamSequenceDictionary sequences;
-    sequences.Add(groups);
-    EXPECT_FALSE(sequences.IsEmpty());
-    EXPECT_EQ(2, sequences.Size());
-}
-
-TEST(SamSequenceDictionaryTest, AddDuplicate) {
-
-    std::vector<BamTools::SamSequence> groups;
-    groups.push_back(BamTools::SamSequence("1", 100));
-    groups.push_back(BamTools::SamSequence("1", 100));
-
-    // add duplicates through Add()
-    BamTools::SamSequenceDictionary sequences;
-    sequences.Add(groups);
-    EXPECT_FALSE(sequences.IsEmpty());
-    EXPECT_EQ(1, sequences.Size());     // duplicate should not get added
-
-    // add duplicates through operator[]
-    sequences.Clear();
-    sequences["1"] = groups.at(0);
-    sequences["1"] = groups.at(0);
-    EXPECT_FALSE(sequences.IsEmpty());
-    EXPECT_EQ(1, sequences.Size());     // duplicate should not get added
-}
-
-TEST(SamSequenceDictionaryTest, Clear) {
-
-    // add a sequence
-    BamTools::SamSequenceDictionary sequences;
-    sequences.Add(BamTools::SamSequence());
-    EXPECT_FALSE(sequences.IsEmpty());
-    EXPECT_EQ(1, sequences.Size());;
-
-    // test clear
-    sequences.Clear();
-    EXPECT_TRUE(sequences.IsEmpty());
-    EXPECT_EQ(0, sequences.Size());
-}
-
-#endif // SAMSEQUENCEDICTIONARY_TEST_H

diff --git a/src/test/api/SamHeaderValidationTest.h b/src/test/api/SamHeaderValidationTest.h
new file mode 100644 (file)
index 0000000..4b59505
--- /dev/null
+++ b/src/test/api/SamHeaderValidationTest.h
@@ -0,0 +1,292 @@
+#ifndef SAMHEADER_VALIDATIONTEST_H
+#define SAMHEADER_VALIDATIONTEST_H
+
+#include "api/SamHeader.h"
+#include <gtest/gtest.h>
+#include <iostream>
+#include <string>
+
+TEST(SamHeader_ValidationTest, EmptyHeader) {
+
+    BamTools::SamHeader header("");
+    std::string headerText = header.ToString();
+    ASSERT_TRUE(headerText.empty());
+    EXPECT_TRUE(header.IsValid());
+}
+
+TEST(SamHeader_ValidationTest, Version) {
+
+    BamTools::SamHeader header("");
+
+    // empty - VALID HEADER
+    header.Version = "";
+    EXPECT_TRUE(header.IsValid());
+
+    // normal - VALID HEADER
+    header.Version = "1.1";
+    EXPECT_TRUE(header.IsValid());
+    header.Version = "11.1";
+    EXPECT_TRUE(header.IsValid());
+    header.Version = "1.11";
+
+    // no period - INVALID HEADER
+    header.Version = "11";
+    EXPECT_FALSE(header.IsValid());
+
+    // no major - INVALID HEADER
+    header.Version = ".1";
+    EXPECT_FALSE(header.IsValid());
+
+    // invalid major - INVALID HEADER
+    header.Version = "a.1";
+    EXPECT_FALSE(header.IsValid());
+
+    // no minor - INVALID HEADER
+    header.Version = "1.";
+    EXPECT_FALSE(header.IsValid());
+
+    // invalid minor - INVALID HEADER
+    header.Version = "1.a";
+    EXPECT_FALSE(header.IsValid());
+}
+
+TEST(SamHeader_ValidationTest, GroupOrder) {
+
+    BamTools::SamHeader header("");
+
+    // empty - VALID HEADER
+    header.GroupOrder = "";
+    EXPECT_TRUE(header.IsValid());
+
+    // normal group order- VALID HEADER
+    header.GroupOrder = "none";
+    EXPECT_TRUE(header.IsValid());
+    header.GroupOrder = "query";
+    EXPECT_TRUE(header.IsValid());
+    header.GroupOrder = "reference";
+    EXPECT_TRUE(header.IsValid());
+
+    // invalid group order - INVALID HEADER
+    header.GroupOrder = "fake";
+    EXPECT_FALSE(header.IsValid());
+}
+
+TEST(SamHeader_ValidationTest, SortOrder) {
+
+    BamTools::SamHeader header("");
+
+    // empty - VALID HEADER
+    header.SortOrder = "";
+    EXPECT_TRUE(header.IsValid());
+
+    // normal sort order- VALID HEADER
+    header.SortOrder = "coordinate";
+    EXPECT_TRUE(header.IsValid());
+    header.SortOrder = "queryname";
+    EXPECT_TRUE(header.IsValid());
+    header.SortOrder = "unsorted";
+    EXPECT_TRUE(header.IsValid());
+
+    // invalid sort order - INVALID HEADER
+    header.SortOrder = "fake";
+    EXPECT_FALSE(header.IsValid());
+}
+
+TEST(SamHeader_ValidationTest, SequenceDictionary) {
+
+    BamTools::SamHeader header("");
+    BamTools::SamSequence sequence;
+
+    // --------------------------------
+    // empty - VALID HEADER
+
+    header.Sequences.Clear();
+    EXPECT_TRUE(header.IsValid());
+
+    // --------------------------------
+    // normal - VALID HEADER
+
+    sequence.Name   = "MT";
+    sequence.Length = "1000";
+    header.Sequences.Add(sequence);
+    EXPECT_TRUE(header.IsValid());
+
+    // normal ( length == MIN )
+    sequence.Name   = "MT";
+    sequence.Length = "1";
+    header.Sequences.Clear();
+    header.Sequences.Add(sequence);
+    EXPECT_TRUE(header.IsValid());
+
+    // normal ( length == MAX )
+    sequence.Name = "MT";
+    sequence.Length = "536870911";
+    header.Sequences.Clear();
+    header.Sequences.Add(sequence);
+    EXPECT_TRUE(header.IsValid());
+
+    // ---------------------------------
+    // missing required info - INVALID HEADER
+
+    // missing ID
+    sequence.Name = "";
+    sequence.Length = "1000";
+    header.Sequences.Clear();
+    header.Sequences.Add(sequence);
+    EXPECT_FALSE(header.IsValid());
+
+    // missing length
+    sequence.Name = "MT";
+    sequence.Length = "";
+    header.Sequences.Clear();
+    header.Sequences.Add(sequence);
+    EXPECT_FALSE(header.IsValid());
+
+    // -------------------------------------
+    // improper SN format - INVALID HEADER
+
+    // starts with *
+    sequence.Name = "*MT";
+    sequence.Length = "1000";
+    header.Sequences.Clear();
+    header.Sequences.Add(sequence);
+    EXPECT_FALSE(header.IsValid());
+
+    // starts with =
+    sequence.Name = "=MT";
+    sequence.Length = "1000";
+    header.Sequences.Clear();
+    header.Sequences.Add(sequence);
+    EXPECT_FALSE(header.IsValid());
+
+    // -----------------------------------------
+    // nonunique ID - INVALID HEADER
+
+    // this behavior is blocked by SamSequenceDictionary
+    // see SamSequenceDictionaryTest::AddDuplicateOk
+
+    // --------------------------------------------
+    // invalid length  - INVALID HEADER
+
+    // length = 0 (MIN == 1)
+    sequence.Name = "MT";
+    sequence.Length = "0";
+    header.Sequences.Clear();
+    header.Sequences.Add(sequence);
+    EXPECT_FALSE(header.IsValid());
+
+    // length = -1
+    sequence.Name = "MT";
+    sequence.Length = "-1";
+    header.Sequences.Clear();
+    header.Sequences.Add(sequence);
+    EXPECT_FALSE(header.IsValid());
+
+    // length = MAX + 1
+    sequence.Name ="MT";
+    sequence.Length = "536870912";
+    header.Sequences.Clear();
+    header.Sequences.Add(sequence);
+    EXPECT_FALSE(header.IsValid());
+}
+
+TEST(SamHeader_ValidationTest, ReadGroupDictionary) {
+
+    BamTools::SamHeader header("");
+    BamTools::SamReadGroup readGroup;
+
+    // ---------------------------------
+    // empty - VALID HEADER
+
+    header.ReadGroups.Clear();
+    EXPECT_TRUE(header.IsValid());
+
+    // ---------------------------------
+    // normal - VALID HEADER
+
+    readGroup.ID = "Group123";
+    readGroup.PlatformUnit = "PU001";
+
+    // technology: none
+    header.ReadGroups.Clear();
+    header.ReadGroups.Add(readGroup);
+    EXPECT_TRUE(header.IsValid());
+
+    // technology: capillary
+    readGroup.SequencingTechnology = "CAPILLARY";
+    header.ReadGroups.Clear();
+    header.ReadGroups.Add(readGroup);
+    EXPECT_TRUE(header.IsValid());
+
+    // technology: Helicos
+    readGroup.SequencingTechnology = "HELICOS";
+    header.ReadGroups.Clear();
+    header.ReadGroups.Add(readGroup);
+    EXPECT_TRUE(header.IsValid());
+
+    // technology: Illumina
+    readGroup.SequencingTechnology = "ILLUMINA";
+    header.ReadGroups.Clear();
+    header.ReadGroups.Add(readGroup);
+    EXPECT_TRUE(header.IsValid());
+
+    // technology: IonTorrent
+    readGroup.SequencingTechnology = "IONTORRENT";
+    header.ReadGroups.Clear();
+    header.ReadGroups.Add(readGroup);
+    EXPECT_TRUE(header.IsValid());
+
+    // technology: 454
+    readGroup.SequencingTechnology = "LS454";
+    header.ReadGroups.Clear();
+    header.ReadGroups.Add(readGroup);
+    EXPECT_TRUE(header.IsValid());
+
+    // technology: Pacific Bio
+    readGroup.SequencingTechnology = "PACBIO";
+    header.ReadGroups.Clear();
+    header.ReadGroups.Add(readGroup);
+    EXPECT_TRUE(header.IsValid());
+
+    // technology: Solid
+    readGroup.SequencingTechnology = "SOLID";
+    header.ReadGroups.Clear();
+    header.ReadGroups.Add(readGroup);
+    EXPECT_TRUE(header.IsValid());
+
+    // ---------------------------------
+    // missing ID - INVALID HEADER
+
+    readGroup.ID = "";
+    header.ReadGroups.Clear();
+    header.ReadGroups.Add(readGroup);
+    EXPECT_FALSE(header.IsValid());
+
+    // -----------------------------------------
+    // nonunique ID - INVALID HEADER
+
+    // this behavior is blocked by SamReadGroupDictionary
+    // see SamReadGroupDictionaryTest::AddDuplicateOk
+
+    // ------------------------------------------
+    // nonunique platform unit - INVALID HEADER
+
+    BamTools::SamReadGroup dupPU("Group1");
+    BamTools::SamReadGroup dupPU2("Group2");
+    dupPU.PlatformUnit = "PU001";
+    dupPU2.PlatformUnit = "PU001";
+    header.ReadGroups.Clear();
+    header.ReadGroups.Add(dupPU);
+    header.ReadGroups.Add(dupPU2);
+    EXPECT_FALSE(header.IsValid());
+
+    // ------------------------------------------------
+    // invalid sequencing technology - INVALID HEADER
+
+    readGroup.SequencingTechnology = "fake";
+    header.ReadGroups.Clear();
+    header.ReadGroups.Add(readGroup);
+    EXPECT_FALSE(header.IsValid());
+}
+
+#endif // SAMHEADER_VALIDATIONTEST_H

diff --git a/src/test/api/SamReadGroupDictionaryTest.h b/src/test/api/SamReadGroupDictionaryTest.h
new file mode 100644 (file)
index 0000000..ccf8d89
--- /dev/null
+++ b/src/test/api/SamReadGroupDictionaryTest.h
@@ -0,0 +1,68 @@
+#ifndef SAMREADGROUPDICTIONARY_TEST_H
+#define SAMREADGROUPDICTIONARY_TEST_H
+
+#include "api/SamReadGroupDictionary.h"
+#include <gtest/gtest.h>
+#include <vector>
+
+TEST(SamReadGroupDictionaryTest, Empty) {
+    BamTools::SamReadGroupDictionary readGroups;
+    EXPECT_TRUE(readGroups.IsEmpty());
+    EXPECT_EQ(0, readGroups.Size());
+}
+
+TEST(SamReadGroupDictionaryTest, AddOne) {
+
+    BamTools::SamReadGroupDictionary readGroups;
+    readGroups.Add(BamTools::SamReadGroup());
+    EXPECT_FALSE(readGroups.IsEmpty());
+    EXPECT_EQ(1, readGroups.Size());
+}
+
+TEST(SamReadGroupDictionaryTest, AddMulti) {
+
+    std::vector<BamTools::SamReadGroup> groups;
+    groups.push_back(BamTools::SamReadGroup("1"));
+    groups.push_back(BamTools::SamReadGroup("2"));
+
+    BamTools::SamReadGroupDictionary readGroups;
+    readGroups.Add(groups);
+    EXPECT_FALSE(readGroups.IsEmpty());
+    EXPECT_EQ(2, readGroups.Size());
+}
+
+TEST(SamReadGroupDictionaryTest, AddDuplicate) {
+
+    std::vector<BamTools::SamReadGroup> groups;
+    groups.push_back(BamTools::SamReadGroup("1"));
+    groups.push_back(BamTools::SamReadGroup("1"));
+
+    // add duplicates through Add()
+    BamTools::SamReadGroupDictionary readGroups;
+    readGroups.Add(groups);
+    EXPECT_FALSE(readGroups.IsEmpty());
+    EXPECT_EQ(1, readGroups.Size());    // duplicate should not get added
+
+    // add duplicates through operator[]
+    readGroups.Clear();
+    readGroups["1"] = groups.at(0);
+    readGroups["1"] = groups.at(0);
+    EXPECT_FALSE(readGroups.IsEmpty());
+    EXPECT_EQ(1, readGroups.Size());     // duplicate should not get added
+}
+
+TEST(SamReadGroupDictionaryTest, Clear) {
+
+    // add a read group
+    BamTools::SamReadGroupDictionary readGroups;
+    readGroups.Add(BamTools::SamReadGroup());
+    EXPECT_FALSE(readGroups.IsEmpty());
+    EXPECT_EQ(1, readGroups.Size());;
+
+    // test clear
+    readGroups.Clear();
+    EXPECT_TRUE(readGroups.IsEmpty());
+    EXPECT_EQ(0, readGroups.Size());
+}
+
+#endif // SAMREADGROUPDICTIONARY_TEST_H

diff --git a/src/test/api/SamSequenceDictionaryTest.h b/src/test/api/SamSequenceDictionaryTest.h
new file mode 100644 (file)
index 0000000..bd75e1e
--- /dev/null
+++ b/src/test/api/SamSequenceDictionaryTest.h
@@ -0,0 +1,69 @@
+#ifndef SAMSEQUENCEDICTIONARY_TEST_H
+#define SAMSEQUENCEDICTIONARY_TEST_H
+
+#include "api/SamSequenceDictionary.h"
+#include <gtest/gtest.h>
+#include <vector>
+
+TEST(SamSequenceDictionaryTest, Empty) {
+
+    BamTools::SamSequenceDictionary sequences;
+    EXPECT_TRUE(sequences.IsEmpty());
+    EXPECT_EQ(0, sequences.Size());
+}
+
+TEST(SamSequenceDictionaryTest, AddOne) {
+
+    BamTools::SamSequenceDictionary sequences;
+    sequences.Add(BamTools::SamSequence());
+    EXPECT_FALSE(sequences.IsEmpty());
+    EXPECT_EQ(1, sequences.Size());
+}
+
+TEST(SamSequenceDictionaryTest, AddMulti) {
+
+    std::vector<BamTools::SamSequence> groups;
+    groups.push_back(BamTools::SamSequence("1", 100));
+    groups.push_back(BamTools::SamSequence("2", 100));
+
+    BamTools::SamSequenceDictionary sequences;
+    sequences.Add(groups);
+    EXPECT_FALSE(sequences.IsEmpty());
+    EXPECT_EQ(2, sequences.Size());
+}
+
+TEST(SamSequenceDictionaryTest, AddDuplicate) {
+
+    std::vector<BamTools::SamSequence> groups;
+    groups.push_back(BamTools::SamSequence("1", 100));
+    groups.push_back(BamTools::SamSequence("1", 100));
+
+    // add duplicates through Add()
+    BamTools::SamSequenceDictionary sequences;
+    sequences.Add(groups);
+    EXPECT_FALSE(sequences.IsEmpty());
+    EXPECT_EQ(1, sequences.Size());     // duplicate should not get added
+
+    // add duplicates through operator[]
+    sequences.Clear();
+    sequences["1"] = groups.at(0);
+    sequences["1"] = groups.at(0);
+    EXPECT_FALSE(sequences.IsEmpty());
+    EXPECT_EQ(1, sequences.Size());     // duplicate should not get added
+}
+
+TEST(SamSequenceDictionaryTest, Clear) {
+
+    // add a sequence
+    BamTools::SamSequenceDictionary sequences;
+    sequences.Add(BamTools::SamSequence());
+    EXPECT_FALSE(sequences.IsEmpty());
+    EXPECT_EQ(1, sequences.Size());;
+
+    // test clear
+    sequences.Clear();
+    EXPECT_TRUE(sequences.IsEmpty());
+    EXPECT_EQ(0, sequences.Size());
+}
+
+#endif // SAMSEQUENCEDICTIONARY_TEST_H

diff --git a/src/test/api/internal/index/BamIndexFactoryTest.h b/src/test/api/internal/index/BamIndexFactoryTest.h
new file mode 100644 (file)
index 0000000..f6755df
--- /dev/null
+++ b/src/test/api/internal/index/BamIndexFactoryTest.h
@@ -0,0 +1,89 @@
+#ifndef BAMINDEX_FACTORYTEST_H
+#define BAMINDEX_FACTORYTEST_H
+
+#include "api/BamIndex.h"
+#include "api/internal/index/BamIndexFactory_p.h"
+#include "api/internal/index/BamStandardIndex_p.h"
+#include "api/internal/index/BamToolsIndex_p.h"
+
+#include <gtest/gtest.h>
+#include <iostream>
+#include <string>
+
+TEST(BamIndex_FactoryTest, CreateIndexFilename) {
+
+    const std::string bamFilename      = "dummy.bam";
+    const std::string baiIndexFilename = BamTools::Internal::BamIndexFactory::CreateIndexFilename(bamFilename, BamTools::BamIndex::STANDARD);
+    const std::string btiIndexFilename = BamTools::Internal::BamIndexFactory::CreateIndexFilename(bamFilename, BamTools::BamIndex::BAMTOOLS);
+
+    EXPECT_EQ("dummy.bam.bai", baiIndexFilename);
+    EXPECT_EQ("dummy.bam.bti", btiIndexFilename);
+}
+
+TEST(BamIndex_FactoryTest, FileExtension) {
+
+    const std::string bamFilename      = "dummy.bam";
+    const std::string baiIndexFilename = "dummy.bam.bai";
+    const std::string btiIndexFilename = "path/to/dummy.bam.bti";
+
+    const std::string bamExtension = BamTools::Internal::BamIndexFactory::FileExtension(bamFilename);
+    const std::string baiExtension = BamTools::Internal::BamIndexFactory::FileExtension(baiIndexFilename);
+    const std::string btiExtension = BamTools::Internal::BamIndexFactory::FileExtension(btiIndexFilename);
+
+    EXPECT_EQ(".bam", bamExtension);
+    EXPECT_EQ(".bai", baiExtension);
+    EXPECT_EQ(".bti", btiExtension);
+
+    // TODO: try some invalid values, just to make sure this is robust/safe enough
+}
+
+TEST(BamIndex_FactoryTest, CreateIndexFromFilename) {
+
+    const std::string baiIndexFilename = "../data/ex1.bam.bai";
+    const std::string btiIndexFilename = "../data/ex1.bam.bti";
+
+    BamTools::BamIndex* bai = BamTools::Internal::BamIndexFactory::CreateIndexFromFilename(baiIndexFilename, 0);
+    BamTools::BamIndex* bti = BamTools::Internal::BamIndexFactory::CreateIndexFromFilename(btiIndexFilename, 0);
+
+    ASSERT_TRUE(bai != NULL);
+    ASSERT_TRUE(bti != NULL);
+
+    EXPECT_EQ(BamTools::BamIndex::STANDARD, bai->Type());
+    EXPECT_EQ(BamTools::BamIndex::BAMTOOLS, bti->Type());
+
+    delete bai;
+    delete bti;
+
+    std::cerr << "TestMessage 4" << std::endl;
+}
+
+TEST(BamIndex_FactoryTest, CreateIndexOfType) {
+
+    BamTools::BamIndex* bai = BamTools::Internal::BamIndexFactory::CreateIndexOfType(BamTools::BamIndex::STANDARD, 0);
+    BamTools::BamIndex* bti = BamTools::Internal::BamIndexFactory::CreateIndexOfType(BamTools::BamIndex::BAMTOOLS, 0);
+
+    EXPECT_EQ(BamTools::BamIndex::STANDARD, bai->Type());
+    EXPECT_EQ(BamTools::BamIndex::BAMTOOLS, bti->Type());
+
+    delete bai;
+    delete bti;
+}
+
+TEST(BamIndex_FactoryTest, FindIndexFilename) {
+
+    // Both BAI & BTI are available
+    const std::string bamFilename = "../data/ex1.bam";
+    const std::string baiIndexFilename = BamTools::Internal::BamIndexFactory::FindIndexFilename(bamFilename, BamTools::BamIndex::STANDARD);
+    const std::string btiIndexFilename = BamTools::Internal::BamIndexFactory::FindIndexFilename(bamFilename, BamTools::BamIndex::BAMTOOLS);
+    EXPECT_EQ("../data/ex1.bam.bai", baiIndexFilename);
+    EXPECT_EQ("../data/ex1.bam.bti", btiIndexFilename);
+
+    // No BTI index available, both requests should fall back to BAI
+    const std::string bamFilename2 = "../data/BCM.ceph.chr20.bam";
+    const std::string baiIndexFilename2 = BamTools::Internal::BamIndexFactory::FindIndexFilename(bamFilename2, BamTools::BamIndex::STANDARD);
+    const std::string btiIndexFilename2 = BamTools::Internal::BamIndexFactory::FindIndexFilename(bamFilename2, BamTools::BamIndex::BAMTOOLS);
+    EXPECT_EQ("../data/BCM.ceph.chr20.bam.bai", baiIndexFilename2);
+    EXPECT_EQ("../data/BCM.ceph.chr20.bam.bai", btiIndexFilename2);
+}
+
+#endif // BAMINDEX_FACTORYTEST_H

diff --git a/src/test/api/internal/index/BamStandardIndexTest.h b/src/test/api/internal/index/BamStandardIndexTest.h
new file mode 100644 (file)
index 0000000..ca1aadd
--- /dev/null
+++ b/src/test/api/internal/index/BamStandardIndexTest.h
@@ -0,0 +1,13 @@
+#ifndef BAMSTANDARDINDEX_TEST_H
+#define BAMSTANDARDINDEX_TEST_H
+
+#include <gtest/gtest.h>
+#include "api/internal/index/BamStandardIndex_p.h"
+
+TEST(BamStandardIndexTest, Open) {
+
+
+
+}
+
+#endif // BAMSTANDARDINDEX_TEST_H

diff --git a/src/test/api/internal/index/BamToolsIndexTest.h b/src/test/api/internal/index/BamToolsIndexTest.h
new file mode 100644 (file)
index 0000000..e1b6cd4
--- /dev/null
+++ b/src/test/api/internal/index/BamToolsIndexTest.h
@@ -0,0 +1,13 @@
+#ifndef BAMTOOLSINDEX_TEST_H
+#define BAMTOOLSINDEX_TEST_H
+
+#include <gtest/gtest.h>
+#include "api/internal/index/BamToolsIndex_p.h"
+
+TEST(BamToolsIndexTest, Open) {
+
+
+
+}
+
+#endif // BAMTOOLSINDEX_TEST_H

diff --git a/src/test/toolkit/BamToolsToolkitTest.h b/src/test/toolkit/BamToolsToolkitTest.h
new file mode 100644 (file)
index 0000000..2655cdd
--- /dev/null
+++ b/src/test/toolkit/BamToolsToolkitTest.h
@@ -0,0 +1,6 @@
+#ifndef BAMTOOLS_TEST_TOOLKIT_H
+#define BAMTOOLS_TEST_TOOLKIT_H
+
+
+#endif // BAMTOOLS_TEST_TOOLKIT_H
+

diff --git a/src/test/utils/BamToolsUtilsTest.h b/src/test/utils/BamToolsUtilsTest.h
new file mode 100644 (file)
index 0000000..6e7b060
--- /dev/null
+++ b/src/test/utils/BamToolsUtilsTest.h
@@ -0,0 +1,6 @@
+#ifndef BAMTOOLS_TEST_UTILS_H
+#define BAMTOOLS_TEST_UTILS_H
+
+
+#endif // BAMTOOLS_TEST_UTILS_H
+