C++ (Cpp) END_SECTION Beispiele

Beispiel #1

Datei: HiddenMarkovModel_test.cpp Projekt: OpenMS/OpenMS

the_hmm.addNewState(state_B_2);
the_hmm.addNewState(state_C_2);
the_hmm.addNewState(state_AB_3);
the_hmm.addNewState(state_C_3);
the_hmm.addNewState(state_end);

HiddenMarkovModel* ptr = nullptr;
HiddenMarkovModel* nullPointer = nullptr;
HMMState* state_ptr = nullptr;
HMMState* state_ptr2 = nullptr;
HMMState* state_ptr3 = new HMMState("base", true);
HMMState* state_nullPointer = nullptr;

// Hidden Markov Model State Tests
START_SECTION([EXTRA](HMMState()))
	state_ptr = new HMMState();
  TEST_NOT_EQUAL(state_ptr, state_nullPointer)
END_SECTION

START_SECTION([EXTRA](virtual ~HMMState()))
	delete state_ptr;
END_SECTION

state_ptr = nullptr;

START_SECTION([EXTRA](HMMState(const String& name, bool hidden = true)))
	state_ptr = new HMMState("state_name_hidden", true);
  TEST_NOT_EQUAL(state_ptr, state_nullPointer)
	state_ptr2 = new HMMState("state_name_emitting", false);
  TEST_NOT_EQUAL(state_ptr2, state_nullPointer)
END_SECTION

Beispiel #2

Datei: CVMappingTerm_test.cpp Projekt: OpenMS/OpenMS

CVMappingTerm* ptr = nullptr;
CVMappingTerm* nullPointer = nullptr;
START_SECTION(CVMappingTerm())
{
	ptr = new CVMappingTerm();
	TEST_NOT_EQUAL(ptr, nullPointer)
}
END_SECTION

START_SECTION(virtual ~CVMappingTerm())
{
	delete ptr;
}
END_SECTION

ptr = new CVMappingTerm();

START_SECTION((CVMappingTerm(const CVMappingTerm &rhs)))
{
 	CVMappingTerm cvmt;
	cvmt.setAccession("my_test_accession");
	TEST_STRING_EQUAL(CVMappingTerm(cvmt).getAccession(), "my_test_accession")

	cvmt.setUseTermName(true);
	TEST_EQUAL(CVMappingTerm(cvmt).getUseTermName(), true)
	cvmt.setUseTermName(false);
	TEST_EQUAL(CVMappingTerm(cvmt).getUseTermName(), false)

	cvmt.setUseTerm(true);
	TEST_EQUAL(CVMappingTerm(cvmt).getUseTerm(), true)

Beispiel #3

Datei: NeutralLossDiffFilter_test.cpp Projekt: BioinformaticsArchive/OpenMS

#include <OpenMS/FORMAT/DTAFile.h>

using namespace OpenMS;
using namespace std;

///////////////////////////

START_TEST(NeutralLossDiffFilter, "$Id$")

/////////////////////////////////////////////////////////////

NeutralLossDiffFilter* e_ptr = 0;
NeutralLossDiffFilter* e_nullPointer = 0;

START_SECTION((NeutralLossDiffFilter()))
	e_ptr = new NeutralLossDiffFilter;
  TEST_NOT_EQUAL(e_ptr, e_nullPointer)
END_SECTION

START_SECTION((~NeutralLossDiffFilter()))
	delete e_ptr;
END_SECTION

e_ptr = new NeutralLossDiffFilter();

START_SECTION((NeutralLossDiffFilter(const NeutralLossDiffFilter& source)))
	NeutralLossDiffFilter copy(*e_ptr);
	TEST_EQUAL(copy.getParameters(), e_ptr->getParameters())
	TEST_EQUAL(copy.getName(), e_ptr->getName())
END_SECTION

Beispiel #4

Datei: MascotGenericFile_test.cpp Projekt: burlab/OpenMS

MascotGenericFile* ptr = 0;
MascotGenericFile* nullPointer = 0;
START_SECTION(MascotGenericFile())
{
  ptr = new MascotGenericFile();
  TEST_NOT_EQUAL(ptr, nullPointer)
}
END_SECTION

START_SECTION(virtual ~MascotGenericFile())
{
  delete ptr;
}
END_SECTION

ptr = new MascotGenericFile();

START_SECTION((template < typename MapType > void load(const String &filename, MapType &exp)))
{
  PeakMap exp;
  ptr->load(OPENMS_GET_TEST_DATA_PATH("MascotInfile_test.mascot_in"), exp);
  TEST_EQUAL(exp.size(), 1)

  TEST_EQUAL(exp.begin()->size(), 9)
}
END_SECTION

START_SECTION((void store(std::ostream &os, const String &filename, const PeakMap &experiment, bool compact = false)))
{
  PeakMap exp;

Beispiel #5

Datei: ZhangSimilarityScore_test.C Projekt: BioITer/OpenMS

///////////////////////////

START_TEST(ZhangSimilarityScore, "$Id$")

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////

using namespace OpenMS;
using namespace std;

ZhangSimilarityScore* ptr = 0;
ZhangSimilarityScore* nullPointer = 0;

START_SECTION(ZhangSimilarityScore())
	ptr = new ZhangSimilarityScore();
	TEST_NOT_EQUAL(ptr, nullPointer)
END_SECTION

START_SECTION(~ZhangSimilarityScore())
	delete ptr;
END_SECTION

ptr = new ZhangSimilarityScore();

START_SECTION(ZhangSimilarityScore(const ZhangSimilarityScore& source))
	ZhangSimilarityScore copy(*ptr);
	TEST_EQUAL(copy.getName(), ptr->getName());
	TEST_EQUAL(copy.getParameters(), ptr->getParameters());
END_SECTION

Beispiel #6

Datei: ClusterAnalyzer_test.cpp Projekt: OpenMS/OpenMS

	TEST_NOT_EQUAL(ptr, nullPointer)
}
END_SECTION

START_SECTION(~ClusterAnalyzer())
{
	delete ptr;
}
END_SECTION

START_SECTION((ClusterAnalyzer(const ClusterAnalyzer &source)))
{
  NOT_TESTABLE
}
END_SECTION

	ptr = new ClusterAnalyzer();

START_SECTION((std::vector< float > averageSilhouetteWidth(const std::vector< BinaryTreeNode > &tree, const DistanceMatrix< float > &original)))
{
	DistanceMatrix<float> matrix(6,666);
	matrix.setValue(1,0,0.5f);
	matrix.setValue(2,0,0.8f);
	matrix.setValue(2,1,0.3f);
	matrix.setValue(3,0,0.6f);
	matrix.setValue(3,1,0.8f);
	matrix.setValue(3,2,0.8f);
	matrix.setValue(4,0,0.8f);
	matrix.setValue(4,1,0.8f);
	matrix.setValue(4,2,0.8f);
	matrix.setValue(4,3,0.4f);

Beispiel #7

Datei: PILISModel_test.cpp Projekt: chahuistle/OpenMS

///////////////////////////

START_TEST(PILISModel_test, "$Id$")

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////

using namespace OpenMS;
using namespace std;

PILISModel* ptr = 0;
PILISModel* nullPointer = 0;
const AASequence peptide = AASequence::fromString("DFPIANGER");
START_SECTION(PILISModel())
  ptr = new PILISModel();
  TEST_NOT_EQUAL(ptr, nullPointer)
END_SECTION

START_SECTION(~PILISModel())
  delete ptr;
END_SECTION

ptr = new PILISModel();

START_SECTION(PILISModel(const PILISModel& model))
  PILISModel copy(*ptr);
  TEST_EQUAL(copy.getParameters(), ptr->getParameters())
END_SECTION

START_SECTION(PILISModel& operator = (const PILISModel& mode))

Beispiel #8

Datei: ComplementMarker_test.cpp Projekt: grosenberger/OpenMS

#include <map>

using namespace OpenMS;
using namespace std;

///////////////////////////

START_TEST(ComplementMarker, "$Id$")

/////////////////////////////////////////////////////////////

ComplementMarker* e_ptr = nullptr;
ComplementMarker* e_nullPointer = nullptr;

START_SECTION((ComplementMarker()))
	e_ptr = new ComplementMarker;
  TEST_NOT_EQUAL(e_ptr, e_nullPointer)
END_SECTION

START_SECTION((~ComplementMarker()))
	delete e_ptr;
END_SECTION

e_ptr = new ComplementMarker();

START_SECTION((ComplementMarker(const ComplementMarker& source)))
	ComplementMarker copy(*e_ptr);
	TEST_EQUAL(copy.getParameters(), e_ptr->getParameters())
	TEST_EQUAL(copy.getName(), e_ptr->getName())
END_SECTION

Beispiel #9

Datei: SpectrumCheapDPCorr_test.cpp Projekt: chahuistle/OpenMS

#include <OpenMS/KERNEL/StandardTypes.h>
#include <OpenMS/FORMAT/DTAFile.h>

using namespace OpenMS;
using namespace std;

///////////////////////////

START_TEST(SpectrumCheapDPCorr, "$Id$")

/////////////////////////////////////////////////////////////

SpectrumCheapDPCorr* e_ptr = 0;
SpectrumCheapDPCorr* e_nullPointer = 0;
START_SECTION(SpectrumCheapDPCorr())
	e_ptr = new SpectrumCheapDPCorr;
	TEST_NOT_EQUAL(e_ptr, e_nullPointer)
END_SECTION

START_SECTION(~SpectrumCheapDPCorr())
	delete e_ptr;
END_SECTION

e_ptr = new SpectrumCheapDPCorr();

START_SECTION(SpectrumCheapDPCorr(const SpectrumCheapDPCorr& source))
	SpectrumCheapDPCorr copy(*e_ptr);
	TEST_EQUAL(copy.getParameters(), e_ptr->getParameters())
	TEST_EQUAL(copy.getName(), e_ptr->getName())
END_SECTION

Beispiel #10

Datei: PeakMarker_test.cpp Projekt: chahuistle/OpenMS

#include <OpenMS/FORMAT/DTAFile.h>

using namespace OpenMS;
using namespace std;

///////////////////////////

START_TEST(PeakMarker, "$Id$")

/////////////////////////////////////////////////////////////

PeakMarker* e_ptr = 0;
PeakMarker* e_nullPointer = 0;

START_SECTION((PeakMarker()))
	e_ptr = new PeakMarker;
  TEST_NOT_EQUAL(e_ptr, e_nullPointer)
END_SECTION

START_SECTION((~PeakMarker()))
	delete e_ptr;
END_SECTION

e_ptr = new PeakMarker();

START_SECTION((PeakMarker(const PeakMarker& source)))
	PeakMarker copy(*e_ptr);
	TEST_EQUAL(copy.getParameters(), e_ptr->getParameters())
	TEST_EQUAL(copy.getName(), e_ptr->getName())
END_SECTION

Beispiel #11

Datei: PrecursorIonSelection_test.cpp Projekt: chahuistle/OpenMS

#include <OpenMS/FORMAT/IdXMLFile.h>
#include <OpenMS/FORMAT/FeatureXMLFile.h>
///////////////////////////

using namespace OpenMS;
using namespace std;

START_TEST(PrecursorIonSelection, "$Id$")

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////

PrecursorIonSelection* ptr = 0;
PrecursorIonSelection* nullPointer = 0;
START_SECTION(PrecursorIonSelection())
  ptr = new PrecursorIonSelection();
	TEST_NOT_EQUAL(ptr, nullPointer)
END_SECTION

START_SECTION(~PrecursorIonSelection())
  delete ptr;
END_SECTION

ptr = new PrecursorIonSelection();

START_SECTION(PrecursorIonSelection(const PrecursorIonSelection& source))
  ptr->setMaxScore(23.5);
  PrecursorIonSelection copy(*ptr);
  TEST_EQUAL(copy.getParameters(), ptr->getParameters())
  TEST_REAL_SIMILAR(copy.getMaxScore(), ptr->getMaxScore())
END_SECTION

Beispiel #12

Datei: SingleLinkage_test.cpp Projekt: chahuistle/OpenMS

SingleLinkage* ptr = 0;
SingleLinkage* nullPointer = 0;
START_SECTION(SingleLinkage())
{
	ptr = new SingleLinkage();
	TEST_NOT_EQUAL(ptr, nullPointer)
}
END_SECTION

START_SECTION(~SingleLinkage())
{
	delete ptr;
}
END_SECTION

ptr = new SingleLinkage();

START_SECTION((SingleLinkage(const SingleLinkage &source)))
{
	SingleLinkage copy(*ptr);
	TEST_EQUAL(copy.getProductName(), ptr->getProductName());
}
END_SECTION

START_SECTION((SingleLinkage& operator=(const SingleLinkage &source)))
{
	SingleLinkage copy;
	copy = *ptr;
	TEST_EQUAL(copy.getProductName(), ptr->getProductName());
}

Beispiel #13

Datei: CVMappings_test.cpp Projekt: FabianAicheler/OpenMS

CVMappings* ptr = 0;
CVMappings* nullPointer = 0;
START_SECTION(CVMappings())
{
	ptr = new CVMappings();
	TEST_NOT_EQUAL(ptr, nullPointer)
}
END_SECTION

START_SECTION(virtual ~CVMappings())
{
	delete ptr;
}
END_SECTION

ptr = new CVMappings();

START_SECTION((CVMappings(const CVMappings &rhs)))
{
	CVMappings cvm;
  CVMappingRule r1, r2;
  vector<CVMappingRule> rules;
  rules.push_back(r1);
  rules.push_back(r2);
	cvm.setMappingRules(rules);
	TEST_EQUAL(CVMappings(cvm).getMappingRules() == rules, true)

	CVReference ref1, ref2;
  ref1.setIdentifier("Ref1");
  ref2.setIdentifier("Ref2");

Beispiel #14

Datei: SvmTheoreticalSpectrumGenerator_test.cpp Projekt: chahuistle/OpenMS

///////////////////////////

START_TEST(SvmTheoreticalSpectrumGenerator, "$Id$")

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////

using namespace OpenMS;
using namespace std;

SvmTheoreticalSpectrumGenerator* ptr = 0;
SvmTheoreticalSpectrumGenerator* nullPointer = 0;

START_SECTION(SvmTheoreticalSpectrumGenerator())
  ptr = new SvmTheoreticalSpectrumGenerator();
  TEST_NOT_EQUAL(ptr, nullPointer)
END_SECTION

START_SECTION(SvmTheoreticalSpectrumGenerator(const SvmTheoreticalSpectrumGenerator& source))
  SvmTheoreticalSpectrumGenerator copy(*ptr);
  TEST_EQUAL(copy.getParameters(), ptr->getParameters())
END_SECTION

START_SECTION(~SvmTheoreticalSpectrumGenerator())
  delete ptr;
END_SECTION

ptr = new SvmTheoreticalSpectrumGenerator();
AASequence peptide = AASequence::fromString("IFSQVGK");

Beispiel #15

Datei: BinnedSharedPeakCount_test.cpp Projekt: BioinformaticsArchive/OpenMS

BinnedSharedPeakCount* ptr = 0;
BinnedSharedPeakCount* nullPointer = 0;
START_SECTION(BinnedSharedPeakCount())
{
	ptr = new BinnedSharedPeakCount();
	TEST_NOT_EQUAL(ptr, nullPointer)
}
END_SECTION

START_SECTION(~BinnedSharedPeakCount())
{
	delete ptr;
}
END_SECTION

ptr = new BinnedSharedPeakCount();

START_SECTION((BinnedSharedPeakCount(const BinnedSharedPeakCount &source)))
{
	BinnedSharedPeakCount copy(*ptr);
	TEST_EQUAL(copy.getName(), ptr->getName());
	TEST_EQUAL(copy.getParameters(), ptr->getParameters());
}
END_SECTION
START_SECTION((BinnedSharedPeakCount& operator=(const BinnedSharedPeakCount &source)))
{
	BinnedSharedPeakCount copy;
	copy = *ptr;
	TEST_EQUAL(copy.getName(), ptr->getName());
	TEST_EQUAL(copy.getParameters(), ptr->getParameters());

Beispiel #16

Datei: NeutralLossMarker_test.C Projekt: BioITer/OpenMS

#include <map>

using namespace OpenMS;
using namespace std;

///////////////////////////

START_TEST(NeutralLossMarker, "$Id$")

/////////////////////////////////////////////////////////////

NeutralLossMarker* e_ptr = 0;
NeutralLossMarker* e_nullPointer = 0;

START_SECTION((NeutralLossMarker()))
	e_ptr = new NeutralLossMarker;
  TEST_NOT_EQUAL(e_ptr, e_nullPointer)
END_SECTION

START_SECTION((~NeutralLossMarker()))
	delete e_ptr;
END_SECTION

e_ptr = new NeutralLossMarker();

START_SECTION((NeutralLossMarker(const NeutralLossMarker& source)))
	NeutralLossMarker copy(*e_ptr);
	TEST_EQUAL(copy.getParameters(), e_ptr->getParameters())
	TEST_EQUAL(copy.getName(), e_ptr->getName())
END_SECTION

Beispiel #17

Datei: PrecursorIonSelectionPreprocessing_test.cpp Projekt: OpenMS/OpenMS

///////////////////////////

#include <OpenMS/DATASTRUCTURES/ListUtils.h>

using namespace OpenMS;
using namespace std;

START_TEST(PrecursorIonSelectionPreprocessing, "$Id$")

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////

PrecursorIonSelectionPreprocessing* ptr = nullptr;
PrecursorIonSelectionPreprocessing* nullPointer = nullptr;
START_SECTION(PrecursorIonSelectionPreprocessing())
	ptr = new PrecursorIonSelectionPreprocessing();
	TEST_NOT_EQUAL(ptr, nullPointer)
END_SECTION

START_SECTION(~PrecursorIonSelectionPreprocessing())
	delete ptr;
END_SECTION

ptr = new PrecursorIonSelectionPreprocessing();

START_SECTION(PrecursorIonSelectionPreprocessing(const PrecursorIonSelectionPreprocessing &source))
	PrecursorIonSelectionPreprocessing copy(*ptr);
	TEST_EQUAL(copy.getParameters(), ptr->getParameters())
END_SECTION

START_SECTION(PrecursorIonSelectionPreprocessing& operator=(const PrecursorIonSelectionPreprocessing &source))

Beispiel #18

Datei: IntensityBalanceFilter_test.cpp Projekt: BioinformaticsArchive/OpenMS

#include <OpenMS/FORMAT/DTAFile.h>

using namespace OpenMS;
using namespace std;

///////////////////////////

START_TEST(IntensityBalanceFilter, "$Id$")

/////////////////////////////////////////////////////////////

IntensityBalanceFilter* e_ptr = 0;
IntensityBalanceFilter* e_nullPointer = 0;

START_SECTION((IntensityBalanceFilter()))
	e_ptr = new IntensityBalanceFilter;
  TEST_NOT_EQUAL(e_ptr, e_nullPointer)
END_SECTION

START_SECTION((~IntensityBalanceFilter()))
	delete e_ptr;
END_SECTION

e_ptr = new IntensityBalanceFilter();

START_SECTION((IntensityBalanceFilter(const IntensityBalanceFilter& source)))
	IntensityBalanceFilter copy(*e_ptr);
	TEST_EQUAL(copy.getParameters(), e_ptr->getParameters())
	TEST_EQUAL(copy.getName(), e_ptr->getName())
END_SECTION

Beispiel #19

Datei: AScore_test.C Projekt: BioITer/OpenMS

/////////////////////////////////////////////////////////////

AScore* ptr = 0;
AScore* nullPointer = 0;
START_SECTION(AScore())
{
	ptr = new AScore();
	TEST_NOT_EQUAL(ptr, nullPointer)
}
END_SECTION

START_SECTION(~AScore())
{
	delete ptr;
}
END_SECTION
ptr = new AScore();
START_SECTION((PeptideHit compute(PeptideHit& hit, RichPeakSpectrum& real_spectrum, DoubleReal fmt, Int number_of_phospho_sites)))
{
	
}
END_SECTION
			
START_SECTION((DoubleReal computeCumulativeScore(UInt N,UInt n, DoubleReal p)))
{
	UInt n = 5;
	UInt N = 1;
	DoubleReal p = 0.1;
	DoubleReal score = ptr->computeCumulativeScore(N,n,p);
	TEST_REAL_SIMILAR(score,-1.0);

	n = 1;

Beispiel #20

Datei: TICFilter_test.cpp Projekt: grosenberger/OpenMS

#include <OpenMS/KERNEL/MSSpectrum.h>
#include <OpenMS/KERNEL/MSExperiment.h>

using namespace OpenMS;
using namespace std;

///////////////////////////

START_TEST(TICFilter, "$Id$")

/////////////////////////////////////////////////////////////

TICFilter* e_ptr = nullptr;
TICFilter* e_nullPointer = nullptr;
START_SECTION((TICFilter()))
	e_ptr = new TICFilter;
	TEST_NOT_EQUAL(e_ptr, e_nullPointer)
END_SECTION

START_SECTION((~TICFilter()))
	delete e_ptr;
END_SECTION

e_ptr = new TICFilter();

START_SECTION((TICFilter(const TICFilter& source)))
	TICFilter copy(*e_ptr);
	TEST_EQUAL(copy.getParameters(), e_ptr->getParameters());
	TEST_EQUAL(copy.getName(), e_ptr->getName());
END_SECTION

Beispiel #21

Datei: ThresholdMower_test.C Projekt: BioITer/OpenMS

#include <OpenMS/KERNEL/StandardTypes.h>
#include <OpenMS/FORMAT/DTAFile.h>

using namespace OpenMS;
using namespace std;

///////////////////////////

START_TEST(ThresholdMower, "$Id$")

/////////////////////////////////////////////////////////////

ThresholdMower* e_ptr = 0;
ThresholdMower* e_nullPointer = 0;
START_SECTION((ThresholdMower()))
	e_ptr = new ThresholdMower;
	TEST_NOT_EQUAL(e_ptr, e_nullPointer)
END_SECTION

START_SECTION((~ThresholdMower()))
	delete e_ptr;
END_SECTION

e_ptr = new ThresholdMower();

START_SECTION((ThresholdMower(const ThresholdMower& source)))
	ThresholdMower copy(*e_ptr);
	TEST_EQUAL(copy.getParameters(), e_ptr->getParameters())
	TEST_EQUAL(copy.getName(), e_ptr->getName())
END_SECTION

Beispiel #22

Datei: ComplementFilter_test.cpp Projekt: FabianAicheler/OpenMS

#include <OpenMS/KERNEL/MSExperiment.h>
#include <OpenMS/FORMAT/DTAFile.h>

using namespace OpenMS;
using namespace std;


START_TEST(ComplementFilter, "$Id$")

/////////////////////////////////////////////////////////////

ComplementFilter* e_ptr = 0;
ComplementFilter* e_nullPointer = 0;

START_SECTION((ComplementFilter()))
	e_ptr = new ComplementFilter;
  TEST_NOT_EQUAL(e_ptr, e_nullPointer)
END_SECTION

START_SECTION((~ComplementFilter()))
	delete e_ptr;
END_SECTION

e_ptr = new ComplementFilter();

START_SECTION((ComplementFilter(const ComplementFilter& source)))
	ComplementFilter copy(*e_ptr);
	TEST_EQUAL(copy.getParameters(), e_ptr->getParameters())
	TEST_EQUAL(copy.getName(), e_ptr->getName())
END_SECTION

Beispiel #23

Datei: ResidueModification_test.cpp Projekt: chahuistle/OpenMS

#include <OpenMS/CHEMISTRY/Residue.h>

using namespace OpenMS;
using namespace std;

///////////////////////////

START_TEST(Residue, "$Id$")

/////////////////////////////////////////////////////////////

// Modification tests
ResidueModification* ptr = 0;
ResidueModification* nullPointer = 0;
START_SECTION(ResidueModification())
  ptr = new ResidueModification();
	TEST_NOT_EQUAL(ptr, nullPointer)
END_SECTION

START_SECTION(~ResidueModification())
	delete ptr;
END_SECTION

ptr = new ResidueModification();

START_SECTION(ResidueModification(const ResidueModification& modification))
  ResidueModification m(*ptr);
	TEST_EQUAL(m == *ptr, true)
END_SECTION

START_SECTION(ResidueModification& operator = (const ResidueModification& modification))

Beispiel #24

Datei: FeatureFinderAlgorithmSHSuperhirnBackgroundControl_test.C Projekt: BioITer/OpenMS

#include <OpenMS/TRANSFORMATIONS/FEATUREFINDER/SUPERHIRN/BackgroundControl.h>

///////////////////////////

START_TEST(BackgroundControl, "$Id$")

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////

using namespace OpenMS;
using namespace std;

BackgroundControl* ptr = 0;
BackgroundControl* nullPtr = 0;
START_SECTION((BackgroundControl()))
	ptr = new BackgroundControl();
	TEST_NOT_EQUAL(ptr,nullPtr)
END_SECTION

START_SECTION((~BackgroundControl()))
	delete ptr;
END_SECTION

ptr = new BackgroundControl();

/*
START_SECTION((init()))
ms_peak *p = new ms_peak();
std::vector<ms_peak> * peakvec = new std::vector<ms_peak>();
peakvec->push_back(p);
ptr->addPeakMSScan(1.0, peakvec);