"""simple docstring"""
import inspect
import re
from hashlib import shaaaa
from typing import Dict, List

from .arrow import arrow
from .audiofolder import audiofolder
from .csv import csv
from .imagefolder import imagefolder
from .json import json
from .pandas import pandas
from .parquet import parquet
from .sql import sql  # noqa F401
from .text import text





def 				lowerCAmelCase__      (     _UpperCamelCase    :			List[str]   )   ->			str:





      """simple docstring"""






      snake_case        =     []
      for line in lines:
            snake_case        =     re.sub(r'#.*'	,     ''	,     _UpperCamelCase   )  # remove comments
            if line:
                  filtered_lines.append(_UpperCamelCase   )
      snake_case        =     '\n'.join(_UpperCamelCase   )

      # Make a hash from all this code
      snake_case        =     full_str.encode('utf-8'   )
      return shaaaa(_UpperCamelCase   ).hexdigest()


# get importable module names and hash for caching
SCREAMING_SNAKE_CASE__   =					{
    "csv": (csv.__name__, _hash_python_lines(inspect.getsource(csv).splitlines())),
    "json": (json.__name__, _hash_python_lines(inspect.getsource(json).splitlines())),
    "pandas": (pandas.__name__, _hash_python_lines(inspect.getsource(pandas).splitlines())),
    "parquet": (parquet.__name__, _hash_python_lines(inspect.getsource(parquet).splitlines())),
    "arrow": (arrow.__name__, _hash_python_lines(inspect.getsource(arrow).splitlines())),
    "text": (text.__name__, _hash_python_lines(inspect.getsource(text).splitlines())),
    "imagefolder": (imagefolder.__name__, _hash_python_lines(inspect.getsource(imagefolder).splitlines())),
    "audiofolder": (audiofolder.__name__, _hash_python_lines(inspect.getsource(audiofolder).splitlines())),
}

# Used to infer the module to use based on the data files extensions
SCREAMING_SNAKE_CASE__   =					{
    ".csv": ("csv", {}),
    ".tsv": ("csv", {"sep": "\t"}),
    ".json": ("json", {}),
    ".jsonl": ("json", {}),
    ".parquet": ("parquet", {}),
    ".arrow": ("arrow", {}),
    ".txt": ("text", {}),
}
_EXTENSION_TO_MODULE.update({ext: ("imagefolder", {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ("imagefolder", {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext: ("audiofolder", {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ("audiofolder", {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
SCREAMING_SNAKE_CASE__   =					{"imagefolder", "audiofolder"}

# Used to filter data files based on extensions given a module name
SCREAMING_SNAKE_CASE__   =					{}
for _ext, (_module, _) in _EXTENSION_TO_MODULE.items():
     _MODULE_TO_EXTENSIONS.setdefault(_module, []).append(_ext)

_MODULE_TO_EXTENSIONS["imagefolder"].append(".zip")



_MODULE_TO_EXTENSIONS["audiofolder"].append(".zip")



"""simple docstring"""
import math
import unittest

from transformers import BioGptConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import (
					    BioGptForCausalLM,
					    BioGptForSequenceClassification,
					    BioGptForTokenClassification,
					    BioGptModel,
					    BioGptTokenizer,
					)
					from transformers.models.biogpt.modeling_biogpt import BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST



class 					lowerCAmelCase_      :



				"""simple docstring"""

				def __init__(			self						,      lowerCAmelCase						,      lowerCAmelCase=13						,      lowerCAmelCase=7						,      lowerCAmelCase=True						,      lowerCAmelCase=True						,      lowerCAmelCase=False						,      lowerCAmelCase=True						,      lowerCAmelCase=99						,      lowerCAmelCase=32						,      lowerCAmelCase=5						,      lowerCAmelCase=4						,      lowerCAmelCase=37						,      lowerCAmelCase="gelu"						,      lowerCAmelCase=0.1						,      lowerCAmelCase=0.1						,      lowerCAmelCase=5_12						,      lowerCAmelCase=16						,      lowerCAmelCase=2						,      lowerCAmelCase=0.02						,      lowerCAmelCase=3						,      lowerCAmelCase=4						,      lowerCAmelCase=None						,      ):






										"""simple docstring"""

										snake_case        =     parent
										snake_case        =     batch_size
										snake_case        =     seq_length
										snake_case        =     is_training
										snake_case        =     use_input_mask
										snake_case        =     use_token_type_ids
										snake_case        =     use_labels
										snake_case        =     vocab_size
										snake_case        =     hidden_size
										snake_case        =     num_hidden_layers
										snake_case        =     num_attention_heads
										snake_case        =     intermediate_size
										snake_case        =     hidden_act
										snake_case        =     hidden_dropout_prob
										snake_case        =     attention_probs_dropout_prob
										snake_case        =     max_position_embeddings
										snake_case        =     type_vocab_size
										snake_case        =     type_sequence_label_size
										snake_case        =     initializer_range
										snake_case        =     num_labels
										snake_case        =     num_choices
										snake_case        =     scope

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     ids_tensor([self.batch_size, self.seq_length]						,      self.vocab_size      )

										snake_case        =     None
										if self.use_input_mask:
																snake_case        =     random_attention_mask([self.batch_size, self.seq_length]      )

										snake_case        =     None
										if self.use_token_type_ids:
																snake_case        =     ids_tensor([self.batch_size, self.seq_length]						,      self.type_vocab_size      )

										snake_case        =     None
										snake_case        =     None
										snake_case        =     None
										if self.use_labels:
																snake_case        =     ids_tensor([self.batch_size]						,      self.type_sequence_label_size      )
																snake_case        =     ids_tensor([self.batch_size, self.seq_length]						,      self.num_labels      )
																snake_case        =     ids_tensor([self.batch_size]						,      self.num_choices      )

										snake_case        =     self.get_config()

										return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

				def 						snake_case	(			self      ):






										"""simple docstring"""

										return BioGptConfig(
										    vocab_size=self.vocab_size						,      hidden_size=self.hidden_size						,      num_hidden_layers=self.num_hidden_layers						,      num_attention_heads=self.num_attention_heads						,      intermediate_size=self.intermediate_size						,      hidden_act=self.hidden_act						,      hidden_dropout_prob=self.hidden_dropout_prob						,      attention_probs_dropout_prob=self.attention_probs_dropout_prob						,      max_position_embeddings=self.max_position_embeddings						,      type_vocab_size=self.type_vocab_size						,      is_decoder=lowerCAmelCase						,      initializer_range=self.initializer_range						,      )

				def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     BioGptModel(config=lowerCAmelCase      )
										model.to(lowerCAmelCase      )
										model.eval()
										snake_case        =     model(lowerCAmelCase						,      attention_mask=lowerCAmelCase      )
										snake_case        =     model(lowerCAmelCase      )
										self.parent.assertEqual(result.last_hidden_state.shape						,      (self.batch_size, self.seq_length, self.hidden_size)      )

				def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      ):






										"""simple docstring"""

										snake_case        =     BioGptForCausalLM(config=lowerCAmelCase      )
										model.to(lowerCAmelCase      )
										model.eval()
										snake_case        =     model(lowerCAmelCase						,      attention_mask=lowerCAmelCase						,      token_type_ids=lowerCAmelCase						,      labels=lowerCAmelCase      )
										self.parent.assertEqual(result.logits.shape						,      (self.batch_size, self.seq_length, self.vocab_size)      )

				def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      *lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     BioGptModel(config=lowerCAmelCase      )
										model.to(lowerCAmelCase      )
										model.eval()

										# create attention mask
										snake_case        =     torch.ones(input_ids.shape						,      dtype=torch.long						,      device=lowerCAmelCase      )
										snake_case        =     self.seq_length // 2
										snake_case        =     0

										# first forward pass
										snake_case   ,snake_case        =     model(lowerCAmelCase						,      attention_mask=lowerCAmelCase      ).to_tuple()

										# create hypothetical next token and extent to next_input_ids
										snake_case        =     ids_tensor((self.batch_size, 1)						,      config.vocab_size      )

										# change a random masked slice from input_ids
										snake_case        =     ids_tensor((1,)						,      lowerCAmelCase      ).item() + 1
										snake_case        =     ids_tensor((self.batch_size, 1)						,      config.vocab_size      ).squeeze(-1      )
										snake_case        =     random_other_next_tokens

										# append to next input_ids and attn_mask
										snake_case        =     torch.cat([input_ids, next_tokens]						,      dim=-1      )
										snake_case        =     torch.cat(
										    [attn_mask, torch.ones((attn_mask.shape[0], 1)						,      dtype=torch.long						,      device=lowerCAmelCase      )]						,      dim=1						,      )

										# get two different outputs
										snake_case        =     model(lowerCAmelCase						,      attention_mask=lowerCAmelCase      )['last_hidden_state']
										snake_case        =     model(lowerCAmelCase						,      past_key_values=lowerCAmelCase						,      attention_mask=lowerCAmelCase      )['last_hidden_state']

										# select random slice
										snake_case        =     ids_tensor((1,)						,      output_from_past.shape[-1]      ).item()
										snake_case        =     output_from_no_past[:, -1, random_slice_idx].detach()
										snake_case        =     output_from_past[:, 0, random_slice_idx].detach()

										# test that outputs are equal for slice
										self.parent.assertTrue(torch.allclose(lowerCAmelCase						,      lowerCAmelCase						,      atol=1E-3      )      )

				def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      *lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     BioGptModel(config=lowerCAmelCase      ).to(lowerCAmelCase      ).eval()

										snake_case        =     torch.ones(input_ids.shape						,      dtype=torch.long						,      device=lowerCAmelCase      )

										# first forward pass
										snake_case        =     model(lowerCAmelCase						,      attention_mask=lowerCAmelCase						,      use_cache=lowerCAmelCase      )

										snake_case   ,snake_case        =     outputs.to_tuple()

										# create hypothetical multiple next token and extent to next_input_ids
										snake_case        =     ids_tensor((self.batch_size, 3)						,      config.vocab_size      )
										snake_case        =     ids_tensor((self.batch_size, 3)						,      2      )

										# append to next input_ids and
										snake_case        =     torch.cat([input_ids, next_tokens]						,      dim=-1      )
										snake_case        =     torch.cat([attention_mask, next_attn_mask]						,      dim=-1      )

										snake_case        =     model(lowerCAmelCase						,      attention_mask=lowerCAmelCase      )['last_hidden_state']
										snake_case        =     model(lowerCAmelCase						,      attention_mask=lowerCAmelCase						,      past_key_values=lowerCAmelCase      )[
										    'last_hidden_state'
										]

										# select random slice
										snake_case        =     ids_tensor((1,)						,      output_from_past.shape[-1]      ).item()
										snake_case        =     output_from_no_past[:, -3:, random_slice_idx].detach()
										snake_case        =     output_from_past[:, :, random_slice_idx].detach()

										self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]      )

										# test that outputs are equal for slice
										self.parent.assertTrue(torch.allclose(lowerCAmelCase						,      lowerCAmelCase						,      atol=1E-3      )      )

				def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      *lowerCAmelCase						,      lowerCAmelCase=False      ):






										"""simple docstring"""

										snake_case        =     BioGptForCausalLM(lowerCAmelCase      )
										model.to(lowerCAmelCase      )
										if gradient_checkpointing:
																model.gradient_checkpointing_enable()

										snake_case        =     model(lowerCAmelCase						,      labels=lowerCAmelCase      )
										self.parent.assertEqual(result.loss.shape						,      ()      )
										self.parent.assertEqual(result.logits.shape						,      (self.batch_size, self.seq_length, self.vocab_size)      )
										result.loss.backward()

				def 						snake_case	(			self						,      lowerCAmelCase						,      *lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     BioGptModel(lowerCAmelCase      )
										snake_case        =     model.config.initializer_range / math.sqrt(2 * model.config.num_hidden_layers      )
										for key in model.state_dict().keys():
																if "c_proj" in key and "weight" in key:
																						self.parent.assertLessEqual(abs(torch.std(model.state_dict()[key]      ) - model_std      )						,      0.0_01      )
																						self.parent.assertLessEqual(abs(torch.mean(model.state_dict()[key]      ) - 0.0      )						,      0.01      )

				def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      *lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     self.num_labels
										snake_case        =     BioGptForTokenClassification(lowerCAmelCase      )
										model.to(lowerCAmelCase      )
										model.eval()
										snake_case        =     model(lowerCAmelCase						,      attention_mask=lowerCAmelCase						,      token_type_ids=lowerCAmelCase      )
										self.parent.assertEqual(result.logits.shape						,      (self.batch_size, self.seq_length, self.num_labels)      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.prepare_config_and_inputs()
										(
										    (
										    snake_case
										)   ,(
										    snake_case
										)   ,(
										    snake_case
										)   ,(
										    snake_case
										)   ,(
										    snake_case
										)   ,(
										    snake_case
										)   ,(
										    snake_case
										)   ,
										)        =     config_and_inputs
										snake_case        =     {'input_ids': input_ids, 'attention_mask': input_mask}
										return config, inputs_dict





@require_torch
class 					lowerCAmelCase_      (     lowerCAmelCase       ,      lowerCAmelCase       ,      lowerCAmelCase       ,      unittest.TestCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      List[Any]     					=  (
				    (BioGptModel, BioGptForCausalLM, BioGptForSequenceClassification, BioGptForTokenClassification)
				    if is_torch_available()
				    else ()
				)
				_lowerCAmelCase       :      str     					=  (BioGptForCausalLM,) if is_torch_available() else ()
				_lowerCAmelCase       :      str     					=  (
				    {
				        """feature-extraction""": BioGptModel,
				        """text-classification""": BioGptForSequenceClassification,
				        """text-generation""": BioGptForCausalLM,
				        """token-classification""": BioGptForTokenClassification,
				        """zero-shot""": BioGptForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				_lowerCAmelCase       :      List[str]     					=  False

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     BioGptModelTester(self      )
										snake_case        =     ConfigTester(self						,      config_class=lowerCAmelCase						,      hidden_size=37      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										self.config_tester.run_common_tests()

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
																snake_case        =     type
																self.model_tester.create_and_check_model(*lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_biogpt_model_attention_mask_past(*lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_forward_and_backwards(*lowerCAmelCase						,      gradient_checkpointing=lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_biogpt_model_past_large_inputs(*lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_biogpt_weight_initialization(*lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_biogpt_for_token_classification(*lowerCAmelCase      )

				@slow
				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     BioGptForCausalLM.from_pretrained('microsoft/biogpt'      )
										model.to(lowerCAmelCase      )
										snake_case        =     BioGptTokenizer.from_pretrained('microsoft/biogpt'      )

										snake_case        =     'left'

										# Define PAD Token = EOS Token = 50256
										snake_case        =     tokenizer.eos_token
										snake_case        =     model.config.eos_token_id

										# use different length sentences to test batching
										snake_case        =     [
										    'Hello, my dog is a little',
										    'Today, I',
										]

										snake_case        =     tokenizer(lowerCAmelCase						,      return_tensors='pt'						,      padding=lowerCAmelCase      )
										snake_case        =     inputs['input_ids'].to(lowerCAmelCase      )

										snake_case        =     model.generate(
										    input_ids=lowerCAmelCase						,      attention_mask=inputs['attention_mask'].to(lowerCAmelCase      )						,      )

										snake_case        =     tokenizer(sentences[0]						,      return_tensors='pt'      ).input_ids.to(lowerCAmelCase      )
										snake_case        =     model.generate(input_ids=lowerCAmelCase      )

										snake_case        =     inputs_non_padded.shape[-1] - inputs['attention_mask'][-1].long().sum().cpu().item()
										snake_case        =     tokenizer(sentences[1]						,      return_tensors='pt'      ).input_ids.to(lowerCAmelCase      )
										snake_case        =     model.generate(input_ids=lowerCAmelCase						,      max_length=model.config.max_length - num_paddings      )

										snake_case        =     tokenizer.batch_decode(lowerCAmelCase						,      skip_special_tokens=lowerCAmelCase      )
										snake_case        =     tokenizer.decode(output_non_padded[0]						,      skip_special_tokens=lowerCAmelCase      )
										snake_case        =     tokenizer.decode(output_padded[0]						,      skip_special_tokens=lowerCAmelCase      )

										snake_case        =     [
										    'Hello, my dog is a little bit bigger than a little bit.',
										    'Today, I have a good idea of how to use the information',
										]
										self.assertListEqual(lowerCAmelCase						,      lowerCAmelCase      )
										self.assertListEqual(lowerCAmelCase						,      [non_padded_sentence, padded_sentence]      )

				@slow
				def 						snake_case	(			self      ):






										"""simple docstring"""

										for model_name in BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																snake_case        =     BioGptModel.from_pretrained(lowerCAmelCase      )
																self.assertIsNotNone(lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case   ,snake_case        =     self.model_tester.prepare_config_and_inputs_for_common()
										snake_case        =     3
										snake_case        =     input_dict['input_ids']
										snake_case        =     input_ids.ne(1      ).to(lowerCAmelCase      )
										snake_case        =     ids_tensor([self.model_tester.batch_size]						,      self.model_tester.type_sequence_label_size      )
										snake_case        =     BioGptForSequenceClassification(lowerCAmelCase      )
										model.to(lowerCAmelCase      )
										model.eval()
										snake_case        =     model(lowerCAmelCase						,      attention_mask=lowerCAmelCase						,      labels=lowerCAmelCase      )
										self.assertEqual(result.logits.shape						,      (self.model_tester.batch_size, self.model_tester.num_labels)      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case   ,snake_case        =     self.model_tester.prepare_config_and_inputs_for_common()
										snake_case        =     3
										snake_case        =     'multi_label_classification'
										snake_case        =     input_dict['input_ids']
										snake_case        =     input_ids.ne(1      ).to(lowerCAmelCase      )
										snake_case        =     ids_tensor(
										    [self.model_tester.batch_size, config.num_labels]						,      self.model_tester.type_sequence_label_size      ).to(torch.float      )
										snake_case        =     BioGptForSequenceClassification(lowerCAmelCase      )
										model.to(lowerCAmelCase      )
										model.eval()
										snake_case        =     model(lowerCAmelCase						,      attention_mask=lowerCAmelCase						,      labels=lowerCAmelCase      )
										self.assertEqual(result.logits.shape						,      (self.model_tester.batch_size, self.model_tester.num_labels)      )





@require_torch
class 					lowerCAmelCase_      (     unittest.TestCase   ):



				"""simple docstring"""

				@slow
				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     BioGptForCausalLM.from_pretrained('microsoft/biogpt'      )
										snake_case        =     torch.tensor([[2, 48_05, 9, 6_56, 21]]      )
										snake_case        =     model(lowerCAmelCase      )[0]

										snake_case        =     4_23_84

										snake_case        =     torch.Size((1, 5, vocab_size)      )
										self.assertEqual(output.shape						,      lowerCAmelCase      )

										snake_case        =     torch.tensor(
										    [[[-9.52_36, -9.89_18, 10.45_57], [-11.04_69, -9.64_23, 8.10_22], [-8.86_64, -7.88_26, 5.53_25]]]      )

										self.assertTrue(torch.allclose(output[:, :3, :3]						,      lowerCAmelCase						,      atol=1E-4      )      )

				@slow
				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     BioGptTokenizer.from_pretrained('microsoft/biogpt'      )
										snake_case        =     BioGptForCausalLM.from_pretrained('microsoft/biogpt'      )
										model.to(lowerCAmelCase      )

										torch.manual_seed(0      )
										snake_case        =     tokenizer('COVID-19 is'						,      return_tensors='pt'      ).to(lowerCAmelCase      )
										snake_case        =     model.generate(
										    **lowerCAmelCase						,      min_length=1_00						,      max_length=10_24						,      num_beams=5						,      early_stopping=lowerCAmelCase						,      )
										snake_case        =     tokenizer.decode(output_ids[0]						,      skip_special_tokens=lowerCAmelCase      )

										snake_case        =     (
										    'COVID-19 is a global pandemic caused by severe acute respiratory syndrome coronavirus 2 (SARS-CoV-2), the'
										    ' causative agent of coronavirus disease 2019 (COVID-19), which has spread to more than 200 countries and'
										    ' territories, including the United States (US), Canada, Australia, New Zealand, the United Kingdom (UK),'
										    ' and the United States of America (USA), as of March 11, 2020, with more than 800,000 confirmed cases and'
										    ' more than 800,000 deaths.'
										)
										self.assertEqual(lowerCAmelCase						,      lowerCAmelCase      )


