def setUp(self):
        self.mapping_file_data = MAPPING_FILE_DATA
        self.mapping_file_headers = ['SampleID', 'BarcodeSequence',
            'LinkerPrimerSequence', 'Treatment', 'DOB', 'Description']
        self.valid_columns = ['Treatment', 'DOB']
        self.support_files_filename = get_qiime_temp_dir()
        self.support_files_filename_spaces = join(get_qiime_temp_dir(),
            'Directory With Spaces/AndNoSpaces')

        # data for the custom axes, contains columns that are gradients
        self.mapping_file_data_gradient = MAPPING_FILE_DATA_GRADIENT
        self.mapping_file_headers_gradient = ['SampleID', 'Treatment', 'Time',
            'Weight', 'Description']

        self.coords_header = ['PC.355', 'PC.635', 'PC.636', 'PC.354']
        self.coords_data = COORDS_DATA
        self.coords_eigenvalues = array([1, 2, 3, 4])
        self.coords_pct = array([40, 30, 20, 10])

        # jackknifed test data
        self.jk_mapping_file_headers = ['SampleID', 'C2', 'C3', 'C4']
        self.jk_mapping_file_data = [['1', 'a', 'b', 'c'], ['2', 'd', 'e', 'f'],
            ['3', 'g', 'h', 'i']]
        self.jk_coords_header = [['1', '2', '3'], ['1', '2', '3'],
            ['1', '2', '3'], ['1', '2', '3']]
        self.jk_coords_data = [array([[1.2, 0.1, -1.2],[-2.5, -4.0, 4.5]]),
            array([[-1.4, 0.05, 1.3],[2.6, 4.1, -4.7]]),
            array([[-1.5, 0.05, 1.6],[2.4, 4.0, -4.8]]),
            array([[-1.5, 0.05, 1.6],[2.4, 4.0, -4.8]])]
        self.jk_coords_eigenvalues = [array([0.80, .11, 0.09]), array([0.76,
            .20,0.04]), array([0.84, .14, 0.02]), array([0.84, .11, 0.05])]
        self.jk_coords_pcts = [array([0.80, .10, 0.10]), array([0.76, .21,
            0.03]), array([0.84, .11, 0.05]), array([0.84, .15, 0.01])]

        self.jk_mapping_file_data_gradient = MAPPING_FILE_DATA_GRADIENT
        self.jk_mapping_file_headers_gradient = ['SampleID', 'Treatment','Time',
            'Weight', 'Description']
        self.jk_coords_header_gradient = [['PC.354','PC.355','PC.635','PC.636'],
            ['PC.354','PC.355','PC.635','PC.636'], ['PC.354','PC.355','PC.635',
            'PC.636'], ['PC.354','PC.355','PC.635','PC.636']]
        self.jk_coords_data_gradient = [array([[1.2, 0.1, -1.2, 1.1],[-2.5,
            -4.0, 4.5, 0.3], [.5, -0.4, 3.5, 1.001], [0.67, 0.23, 1.01, 2.2]]),
            array([[1.2, 1, -0.2, 0.1],[-2.5, -4.0, 4.5, 3.2], [.5, -0.4, 3.5,
            1.00], [0.57, 0.27, 0.95, 2.1]]), array([[1.0, 1, -1.2, 1.1],[-2.1,
            -2.0, 3.5, 0.3], [.5, 3, 3.5, 2], [0.60, 0.33, 1.3, 2.0]]), array([
            [1.2, 0.1, -1.2, 1.1],[-2.5,-4.0, 4.5, 0.3], [.5, -0.4, 3.5, 1.001],
            [0.69, 0.20, 1.01, 2.2]])]
        self.jk_coords_eigenvalues_gradient = [array([0.80, .11, 0.09, 0.0]),
            array([0.76, .20,0.04, 0.0]), array([0.84, .14, 0.02, 0.0]), array([
            0.84, .11, 0.05, 0.0])]
        self.jk_coords_pcts_gradient = [array([0.80, .10, 0.10, 0.0]), array(
            [0.76, .21, 0.03, 0.0]), array([0.84, .11, 0.05, 0.0]), array([0.84,
            .15, 0.01, 0])]

        self.broken_mapping_file_data = BROKEN_MAPPING_FILE
        self.broken_mapping_file_data_2_values = BROKEN_MAPPING_FILE_2_VALUES

    def __call__(self,
                 query_fasta_fp,
                 database_fasta_fp,
                 output_dir,
                 observation_metadata_fp=None,
                 params=None,
                 HALT_EXEC=False):

        if params is None:
            params = {}

        """ Call the DatabaseMapper """
        create_dir(output_dir)
        raw_output_fp = self._get_raw_output_fp(output_dir,
                                                params)
        output_observation_map_fp = '%s/observation_map.txt' % output_dir
        output_biom_fp = '%s/observation_table.biom' % output_dir
        log_fp = '%s/observation_table.log' % output_dir

        self._assign_dna_reads_to_database(
            query_fasta_fp=query_fasta_fp,
            database_fasta_fp=database_fasta_fp,
            raw_output_fp=raw_output_fp,
            temp_dir=get_qiime_temp_dir(),
            params=params,
            HALT_EXEC=HALT_EXEC)

        self._process_raw_output(raw_output_fp,
                                 log_fp,
                                 output_observation_map_fp)

        self._generate_biom_output(output_observation_map_fp,
                                   output_biom_fp,
                                   observation_metadata_fp)

    def setUp(self):
        """ """
        self.files_to_remove = []
        self.dirs_to_remove = []

        tmp_dir = get_qiime_temp_dir()
        self.test_out = mkdtemp(dir=tmp_dir,
                                prefix='qiime_parallel_tests_',
                                suffix='')
        self.dirs_to_remove.append(self.test_out)

        fd, self.template_fp = mkstemp(dir=self.test_out,
                                      prefix='qiime_template',
                                      suffix='.fasta')
        close(fd)
        template_f = open(self.template_fp, 'w')
        template_f.write(pynast_test1_template_fasta)
        template_f.close()
        self.files_to_remove.append(self.template_fp)

        fd, self.inseqs1_fp = mkstemp(dir=self.test_out,
                                     prefix='qiime_inseqs',
                                     suffix='.fasta')
        close(fd)
        inseqs1_f = open(self.inseqs1_fp, 'w')
        inseqs1_f.write(inseqs1)
        inseqs1_f.close()
        self.files_to_remove.append(self.inseqs1_fp)

        initiate_timeout(60)

def multiple_file_DA_fitZIG(input_dir, output_dir, mapping_fp, mapping_category, subcategory_1, subcategory_2):
    """perform metagenomeSeq's Zero Inflated Gaussian (ZIG) OTU differential abundance test on a directory of raw abundance OTU matrices
    """
    if not exists(output_dir):
        makedirs(output_dir)
    file_names = [fname for fname in listdir(input_dir) if not (fname.startswith('.')\
        or isdir(fname))]

    for fname in file_names:
        base_fname, ext = splitext(fname)
        original_fname = base_fname+'.biom'
        hdf5_infile = join(input_dir, original_fname)
        tmp_bt = load_table(hdf5_infile) 
        tmp_pmf, _ = parse_mapping_file_to_dict(mapping_fp)
        check_mapping_file_category(tmp_bt, mapping_fp, mapping_category, subcategory_1, subcategory_2)
        tmp_bt.add_metadata(tmp_pmf, 'sample')
        #make temporary json biom version - R currently does not have hdf5
        outfile = join(output_dir, 'fitZIG_DA_'+base_fname+'.txt')

        with tempfile.NamedTemporaryFile(dir=get_qiime_temp_dir(),
                                         prefix='QIIME-differential-abundance-temp-table-',
                                         suffix='.biom') as temp_fh:
            temp_fh.write(tmp_bt.to_json('forR'))
            temp_fh.flush()
            run_fitZIG(temp_fh.name, outfile, mapping_category, subcategory_1, subcategory_2) 

    def test_split_fasta_diff_num_seqs_per_file(self):
        """split_fasta funcs as expected when diff num seqs go to each file
        """
        _, filename_prefix = mkstemp(dir=get_qiime_temp_dir(),
                                     prefix='split_fasta_tests',
                                     suffix='')
        close(_)
        infile = ['>seq1', 'AACCTTAA', '>seq2', 'TTAACC', 'AATTAA',
                  '>seq3', 'CCTT--AA']

        actual = split_fasta(infile, 2, filename_prefix)

        actual_seqs = []
        for fp in actual:
            actual_seqs += list(open(fp))
        remove_files(actual)

        expected = ['%s.%d.fasta' % (filename_prefix, i) for i in range(2)]
        # list of file paths is as expected
        self.assertEqual(actual, expected)
        # building seq collections from infile and the split files result in
        # equivalent seq collections
        self.assertEqual(
            LoadSeqs(data=infile, aligned=False),
            LoadSeqs(data=actual_seqs, aligned=False))

def multiple_file_DA_DESeq2(input_dir, output_dir, mapping_fp, mapping_category, subcategory_1, subcategory_2, DESeq2_diagnostic_plots):
    """perform DESeq2 negative binomial Wald differential abundance test on a directory of raw abundance OTU matrices
    """
    if not exists(output_dir):
        makedirs(output_dir)
    file_names = [fname for fname in listdir(input_dir) if not (fname.startswith('.')\
        or isdir(fname))]

    for fname in file_names:
        base_fname, ext = splitext(fname)
        original_fname = base_fname+'.biom'
        hdf5_infile = join(input_dir, original_fname)
        tmp_bt = load_table(hdf5_infile)
        tmp_pmf, _ = parse_mapping_file_to_dict(mapping_fp)
        check_mapping_file_category(tmp_bt, mapping_fp, mapping_category, subcategory_1, subcategory_2)
        tmp_bt.add_metadata(tmp_pmf, 'sample')
        outfile = join(output_dir, 'DESeq2_DA_'+base_fname+'.txt') 
        outfile_diagnostic = join(output_dir, 'DESeq2_diagnostic_plots_'+base_fname+'.pdf') 

        with tempfile.NamedTemporaryFile(dir=get_qiime_temp_dir(),
                                         prefix='QIIME-differential-abundance-temp-table-',
                                         suffix='.biom') as temp_fh:
            temp_fh.write(tmp_bt.to_json('forR'))
            temp_fh.flush()
            run_DESeq2(temp_fh.name, outfile, mapping_category, subcategory_1, subcategory_2, DESeq2_diagnostic_plots, outfile_diagnostic) 

    def setUp(self):

        self.files_to_remove = []
        self.dirs_to_remove = []

        # Create example output directory
        tmp_dir = get_qiime_temp_dir()
        self.test_out = mkdtemp(dir=tmp_dir,
                                         prefix='core_qiime_analyses_test_',
                                         suffix='')
        self.dirs_to_remove.append(self.test_out)

        # Get input data
        self.test_data = get_test_data_fps()

        self.qiime_config = load_qiime_config()
        self.qiime_config['jobs_to_start'] = 2
        self.qiime_config['seconds_to_sleep'] = 1

        # suppress stderr during tests (one of the systems calls in the
        # workflow prints a warning, and we can't suppress that warning with
        # warnings.filterwarnings) here because it comes from within the code
        # executed through the system call. Found this trick here:
        # http://stackoverflow.com/questions/9949633/suppressing-print-as-stdout-python
        self.saved_stderr = sys.stderr
        sys.stderr = StringIO()

        # Define number of seconds a test can run for before timing out
        # and failing
        initiate_timeout(600)

 def setUp(self):
     """ """
     self.files_to_remove = []
     self.dirs_to_remove = []
     
     tmp_dir = get_qiime_temp_dir()
     self.test_out = get_tmp_filename(tmp_dir=tmp_dir,
                                      prefix='qiime_parallel_tests_',
                                      suffix='',
                                      result_constructor=str)
     self.dirs_to_remove.append(self.test_out)
     create_dir(self.test_out)
     
     self.template_fp = get_tmp_filename(tmp_dir=self.test_out,
                                         prefix='qiime_template',
                                         suffix='.fasta')
     template_f = open(self.template_fp,'w')
     template_f.write(pynast_test1_template_fasta)
     template_f.close()
     self.files_to_remove.append(self.template_fp)
     
     self.inseqs1_fp = get_tmp_filename(tmp_dir=self.test_out,
                                         prefix='qiime_inseqs',
                                         suffix='.fasta')
     inseqs1_f = open(self.inseqs1_fp,'w')
     inseqs1_f.write(inseqs1)
     inseqs1_f.close()
     self.files_to_remove.append(self.inseqs1_fp)
     
     initiate_timeout(60)

    def test_split_fasta_diff_num_seqs_per_file_alt(self):
        """split_fasta funcs always catches all seqs
        """
        # start with 59 seqs (b/c it's prime, so should make more
        # confusing splits)
        in_seqs = LoadSeqs(data=[('seq%s' % k, 'AACCTTAA') for k in range(59)])
        infile = in_seqs.toFasta().split('\n')

        # test seqs_per_file from 1 to 1000
        for i in range(1, 1000):
            _, filename_prefix = mkstemp(dir=get_qiime_temp_dir(),
                                         prefix='split_fasta_tests',
                                         suffix='')
            close(_)

            actual = split_fasta(infile, i, filename_prefix)

            actual_seqs = []
            for fp in actual:
                actual_seqs += list(open(fp))
            # remove the files now, so if the test fails they still get
            # cleaned up
            remove_files(actual)

            # building seq collections from infile and the split files result in
            # equivalent seq collections
            self.assertEqual(
                LoadSeqs(data=infile, aligned=False),
                LoadSeqs(data=actual_seqs, aligned=False))

    def setUp(self):
        """ """
        self.files_to_remove = []
        self.dirs_to_remove = []

        tmp_dir = get_qiime_temp_dir()
        self.test_out = get_tmp_filename(tmp_dir=tmp_dir,
                                         prefix='qiime_parallel_taxonomy_assigner_tests_',
                                         suffix='',
                                         result_constructor=str)
        self.dirs_to_remove.append(self.test_out)
        create_dir(self.test_out)

        self.tmp_seq_filepath = get_tmp_filename(tmp_dir=self.test_out,
            prefix='qiime_parallel_taxonomy_assigner_tests_input',
            suffix='.fasta')
        seq_file = open(self.tmp_seq_filepath, 'w')
        seq_file.write(blast_test_seqs.toFasta())
        seq_file.close()
        self.files_to_remove.append(self.tmp_seq_filepath)

        self.id_to_taxonomy_file = NamedTemporaryFile(
            prefix='qiime_parallel_taxonomy_assigner_tests_id_to_taxonomy',
            suffix='.txt',dir=tmp_dir)
        self.id_to_taxonomy_file.write(blast_id_to_taxonomy)
        self.id_to_taxonomy_file.seek(0)

        self.reference_seqs_file = NamedTemporaryFile(
            prefix='qiime_parallel_taxonomy_assigner_tests_ref_seqs',
            suffix='.fasta',dir=tmp_dir)
        self.reference_seqs_file.write(blast_reference_seqs.toFasta())
        self.reference_seqs_file.seek(0)

        initiate_timeout(60)

    def setUp(self):
        """ """
        self.test_data = get_test_data_fps()
        self.files_to_remove = []
        self.dirs_to_remove = []

        # Create example output directory
        tmp_dir = get_qiime_temp_dir()
        self.test_out = mkdtemp(dir=tmp_dir,
                                prefix='core_qiime_analyses_test_',
                                suffix='')
        self.dirs_to_remove.append(self.test_out)

        self.qiime_config = load_qiime_config()
        self.params = parse_qiime_parameters(params_f1)

        # suppress stderr during tests (one of the systems calls in the
        # workflow prints a warning, and we can't suppress that warning with
        # warnings.filterwarnings) here because it comes from within the code
        # executed through the system call. Found this trick here:
        # http://stackoverflow.com/questions/9949633/suppressing-print-as-stdout-python
        self.saved_stderr = sys.stderr
        sys.stderr = StringIO()

        initiate_timeout(180)

    def setUp(self):
        """Defines data that will be used by the tests."""
        self.files_to_remove = []
        self.dirs_to_remove = []

        # Create temp directory to hold input and output.
        self.test_dir = mkdtemp(dir=get_qiime_temp_dir(),
                                prefix='qiime_compare_categories_tests_')
        self.dirs_to_remove.append(self.test_dir)

        # Create input files under our temp dir.
        self.dm_fp = join(self.test_dir, 'dm.txt')
        dm_f = open(self.dm_fp, 'w')
        dm_f.write(dm_str)
        dm_f.close()
        self.files_to_remove.append(self.dm_fp)

        self.invalid_dm_fp = join(self.test_dir, 'invalid_dm.txt')
        invalid_dm_f = open(self.invalid_dm_fp, 'w')
        invalid_dm_f.write(invalid_dm_str)
        invalid_dm_f.close()
        self.files_to_remove.append(self.invalid_dm_fp)

        self.map_fp = join(self.test_dir, 'map.txt')
        map_f = open(self.map_fp, 'w')
        map_f.write(map_str)
        map_f.close()
        self.files_to_remove.append(self.map_fp)

        self.cat_methods = ['adonis', 'anosim', 'mrpp', 'permanova',
                            'permdisp', 'dbrda']
        self.num_methods = ['best', 'morans_i']
        self.cat_categories = ['Treatment']
        self.num_categories = ['DOB']
        self.num_perms = 42

    def test_mothur_supported_version(self):
        """mothur is in path and version is supported """
        acceptable_version = (1, 25, 0)
        self.assertTrue(
            which("mothur"),
            "mothur not found. This may or may not be a problem depending on "
            + "which components of QIIME you plan to use.",
        )
        # mothur creates a log file in cwd, so create a tmp and cd there first
        log_file = join(get_qiime_temp_dir(), "mothur.log")
        command = "mothur \"#set.logfile(name=%s)\" | grep '^mothur v'" % log_file
        stdout, stderr, exit_Status = qiime_system_call(command)

        # remove log file
        remove_files([log_file], error_on_missing=False)

        version_string = stdout.strip().split(" ")[1].strip("v.")
        try:
            version = tuple(map(int, version_string.split(".")))
            pass_test = version == acceptable_version
        except ValueError:
            pass_test = False
            version_string = stdout
        self.assertTrue(
            pass_test,
            "Unsupported mothur version. %s is required, but running %s."
            % (".".join(map(str, acceptable_version)), version_string),
        )

    def test_temp_dir(self):
        """temp_dir is set to a valid path"""
        temp_dir = get_qiime_temp_dir()

        self.assertTrue(exists(temp_dir), "temp_dir does not exist: %s" % temp_dir)
        self.assertTrue(isdir(temp_dir), "temp_dir is not a directory: %s" % temp_dir)
        self.assertTrue(access(temp_dir, W_OK), "temp_dir is not writable: %s" % temp_dir)

 def setUp(self):
     
     self.files_to_remove = []
     self.dirs_to_remove = []
     
     # Create example output directory
     tmp_dir = get_qiime_temp_dir()
     self.test_out = get_tmp_filename(tmp_dir=tmp_dir,
                                      prefix='qiime_parallel_tests_',
                                      suffix='',
                                      result_constructor=str)
     self.dirs_to_remove.append(self.test_out)
     create_dir(self.test_out)
     
     # Create example input file
     self.inseqs1_fp = get_tmp_filename(tmp_dir=self.test_out,
                                         prefix='qiime_inseqs',
                                         suffix='.fasta')
     inseqs1_f = open(self.inseqs1_fp,'w')
     inseqs1_f.write(inseqs1)
     inseqs1_f.close()
     self.files_to_remove.append(self.inseqs1_fp)
     
     # Define number of seconds a test can run for before timing out 
     # and failing
     initiate_timeout(60)

    def setUp(self):
        """ """
        self.files_to_remove = []
        self.dirs_to_remove = []

        tmp_dir = get_qiime_temp_dir()
        self.test_out = mkdtemp(dir=tmp_dir,
                                prefix='qiime_parallel_blaster_tests_',
                                suffix='')
        self.dirs_to_remove.append(self.test_out)

        fd, self.tmp_seq_filepath = mkstemp(dir=self.test_out,
                                           prefix='qiime_parallel_blaster_tests_input',
                                           suffix='.fasta')
        close(fd)
        seq_file = open(self.tmp_seq_filepath, 'w')
        seq_file.write(blast_test_seqs)
        seq_file.close()
        self.files_to_remove.append(self.tmp_seq_filepath)

        self.reference_seqs_file = NamedTemporaryFile(
            prefix='qiime_parallel_blaster_tests_ref_seqs',
            suffix='.fasta', dir=tmp_dir)
        self.reference_seqs_file.write(blast_ref_seqs)
        self.reference_seqs_file.seek(0)

        initiate_timeout(60)

    def _generate_training_files(self):
        """Returns a tuple of file objects suitable for passing to the
        RdpTrainer application controller.
        """
        tmp_dir = get_qiime_temp_dir()
        training_set = RdpTrainingSet()
        reference_seqs_file = open(self.Params['reference_sequences_fp'], 'U')
        id_to_taxonomy_file = open(self.Params['id_to_taxonomy_fp'], 'U')

        for seq_id, seq in MinimalFastaParser(reference_seqs_file):
            training_set.add_sequence(seq_id, seq)

        for line in id_to_taxonomy_file:
            seq_id, lineage_str = map(strip, line.split('\t'))
            training_set.add_lineage(seq_id, lineage_str)

        training_set.dereplicate_taxa()

        rdp_taxonomy_file = NamedTemporaryFile(
            prefix='RdpTaxonAssigner_taxonomy_', suffix='.txt', dir=tmp_dir)
        rdp_taxonomy_file.write(training_set.get_rdp_taxonomy())
        rdp_taxonomy_file.seek(0)

        rdp_training_seqs_file = NamedTemporaryFile(
            prefix='RdpTaxonAssigner_training_seqs_', suffix='.fasta',
            dir=tmp_dir)
        for rdp_id, seq in training_set.get_training_seqs():
            rdp_training_seqs_file.write('>%s\n%s\n' % (rdp_id, seq))
        rdp_training_seqs_file.seek(0)

        self._training_set = training_set

        return rdp_taxonomy_file, rdp_training_seqs_file

    def setUp(self):
        """Define some sample data that will be used by the tests."""
        # Standard recipients file with two recipients, one with multiple email
        # addresses.
        self.recipients = ["# a comment", " ", " foo1\[email protected]  ",
                           "foo2\t [email protected],  [email protected],[email protected] "]

        # An empty recipients file.
        self.empty_recipients = ["# a comment", " ", "\n\t\t\t\t"]

        # Standard participants list.
        self.participants = ["# a comment", " ", " foo1  ", "foo2"]

        # Invalid (duplicate) participants list.
        self.duplicate_participants = ["foo1", "foo2", "foo1"]
        
        # The prefix to use for temporary files. This prefix may be added to,
        # but all temp dirs and files created by the tests will have this
        # prefix at a minimum.
        self.prefix = 'my_microbes_tests_'

        self.start_dir = getcwd()
        self.dirs_to_remove = []
        self.files_to_remove = []

        self.tmp_dir = get_qiime_temp_dir()
        if not exists(self.tmp_dir):
            makedirs(self.tmp_dir)
            # If test creates the temp dir, also remove it.
            self.dirs_to_remove.append(self.tmp_dir)

        # Set up temporary input and output directories.
        self.output_dir = mkdtemp(dir=self.tmp_dir,
                                  prefix='%soutput_dir_' % self.prefix)
        self.dirs_to_remove.append(self.output_dir)
        
        # Set up temporary input and output directories.
        self.input_dir = mkdtemp(dir=self.tmp_dir,
                                  prefix='%sinput_dir_' % self.prefix)
        self.dirs_to_remove.append(self.input_dir)

        # Data that will be used by the tests.
        self.otu_cat_sig_gut_fp = join(self.input_dir, 'otu_cat_sig_gut.txt')
        otu_cat_sig_gut_f = open(self.otu_cat_sig_gut_fp, 'w')
        otu_cat_sig_gut_f.write(otu_cat_sig_gut_text)
        otu_cat_sig_gut_f.close()
        self.files_to_remove.append(self.otu_cat_sig_gut_fp)
        
        self.otu_cat_sig_palm_fp = join(self.input_dir, 'otu_cat_sig_palm.txt')
        otu_cat_sig_palm_f = open(self.otu_cat_sig_palm_fp, 'w')
        otu_cat_sig_palm_f.write(otu_cat_sig_gut_text)
        otu_cat_sig_palm_f.close()
        self.files_to_remove.append(self.otu_cat_sig_palm_fp)

        self.rep_seqs_fp = join(self.input_dir, 'rep_seqs.fna')
        rep_seqs_f = open(self.rep_seqs_fp, 'w')
        rep_seqs_f.write(rep_seqs_text)
        rep_seqs_f.close()
        self.files_to_remove.append(self.rep_seqs_fp)

 def setUp(self):
     """ """
     self.files_to_remove = []
     tmp_dir = get_qiime_temp_dir()
     self.test_fp = get_tmp_filename(tmp_dir=tmp_dir,
                                     prefix='bufWriterTest',
                                     suffix='.txt')
     self.files_to_remove.append(self.test_fp)

 def setUp(self):
     """ """
     self.files_to_remove = []
     tmp_dir = get_qiime_temp_dir()
     fd, self.test_fp = mkstemp(dir=tmp_dir,
                               prefix='bufWriterTest',
                               suffix='.txt')
     close(fd)
     self.files_to_remove.append(self.test_fp)