public void Given_Null_Message_Should_Throw_MoodAnalysisException_Indicating_Null_Message()
{
try
{
//Arrange
string message = null;
string fieldName = "message";
//Act
string actual = MoodAnalyserFactory.SetField(message, fieldName);
}
catch (MoodAnalysisException e)
{
//Assert
Assert.AreEqual("message should not be null.", e.Message);
}
}
public void GivenImproperFieldName_ShouldThrowExceptionWithNoField()
{
try
{
//Arrange
string message = "HAPPY";
string fieldName = "mesege";
//Act
string actual = MoodAnalyserFactory.SetField(message, fieldName);
}
catch (MoodAnalyzeException e)
{
//Assert
Assert.AreEqual("no such field found", e.Message);
}
}
public void Given_Improper_Class_Name_Should_Throw_MoodAnalysisException_Indicating_No_Such_Class()
{
try
{
//Arrange
string className = "WrongNamespace.MoodAnalyser";
string constructorName = "MoodAnalyser";
//Act
object resultObj = MoodAnalyserFactory.CreateMoodAnalyserObject(className, constructorName);
}
catch (MoodAnalysisException e)
{
//Assert
Assert.AreEqual("class not found.", e.Message);
}
}
public void GivenNullMessage_ShouldThrowException()
{
try
{
//Arrange
string message = null;
string fieldName = "message";
//Act
string actual = MoodAnalyserFactory.SetField(message, fieldName);
}
catch (MoodAnalyzeException e)
{
//Assert
Assert.AreEqual("message should not be null", e.Message);
}
}
public void GivenMoodAnalyzeImproperConstructorName_ShouldThrowMoodAnalysisExceptionForParameterisedConstructor()
{
try
{
//Arrange
string message = null;
object expected = new MoodAnalyze(message);
//Act
object obj = MoodAnalyserFactory.CreateMoodAnalyserObjectUsingParameterisedConstructor("MoodAnalyzer.MoodAnalyze", "ModAnalize", message);
}
catch (MoodAnalyzeException e)
{
//Assert
Assert.AreEqual("constructor not found", e.Message);
}
}
public void GivenMoodAnalyzeImproperClassName_ShouldThrowMoodAnalysisException()
{
try
{
//Arrange
string message = null;
object expected = new MoodAnalyze(message);
//Act
object obj = MoodAnalyserFactory.CreateMoodAnalyserObject("MoodAnalyzer.ModAnalize", "ModAnalize");
}
catch (MoodAnalyzeException e)
{
//Assert
Assert.AreEqual("class not found", e.Message);
}
}
public void Improper_Class_Name_For_Parametersed_Constructor_Test()
{
try
{
string message = "here i am in happy mood";
string imProperClassName = "Mood";
MoodAnalyser analysis = new MoodAnalyser(message);
MoodAnalyserFactory <MoodAnalyser> factory = new MoodAnalyserFactory <MoodAnalyser>();
ConstructorInfo constrInfo = factory.ConstructorCreator(1);
object instanceOfClass = factory.InstanceCreator(imProperClassName, constrInfo, message);
}
catch (MoodAnalyserException e)
{
Assert.AreEqual(MoodAnalyserException.TypeOfException.NO_CLASS_FOUND, e.exceptionType);
}
}
public void Given_Improper_Method_Name_Should_Throw_MoodAnalysisException_Indicating_No_Such_Method()
{
try
{
//Arrange
string message = "HAPPY";
string methodName = "WrongMethodName";
//Act
string actual = MoodAnalyserFactory.InvokeAnalyseMood(message, methodName);
}
catch (MoodAnalysisException e)
{
//Assert
Assert.AreEqual("no such method.", e.Message);
}
}
public void Given_Improper_Field_Name_Should_Throw_MoodAnalysisException_Indicating_No_Such_Field()
{
try
{
//Arrange
string message = "HAPPY";
string fieldName = "wrongName";
//Act
string actual = MoodAnalyserFactory.SetField(message, fieldName);
}
catch (MoodAnalysisException e)
{
//Assert
Assert.AreEqual("no such field found.", e.Message);
}
}
public void GivenMoodAnalyser_WithWrongConstructorName_ShouldThrowException()
{
try
{
//Arrange
string className = "MoodAnalyser.MoodAnalyser";
string constructor = "MoodAnalyzer";
//Act
object expected = new MoodAnalyser();
object obj = MoodAnalyserFactory.CreateMoodAnalyser(className, constructor);
}
catch (MoodAnalyserException moodException)
{
//Assert
Assert.AreEqual("No such constructor present", moodException.Message);
}
}
public void GivenHappyMoodShouldReturnHappy()
{
string message = "I am in happy mood";
MoodAnalyzer expected = new MoodAnalyzer("I am in happy mood");
object obj = null;
try
{
MoodAnalyserFactory Factory = new MoodAnalyserFactory();
obj = Factory.InvokeAnalyzerMethod(message, "Analyzer");
}
catch (MoodAnalyserException exception)
{
throw new Exception(exception.Message);
}
obj.Equals(expected);
}
public void MoodAnalyseClass_GivenWrongConstructorName_ShouldReturn_NoConstructorException()
{
string expected = "Constructor not found";
try
{
string message = null;
object moodAnalyser = new MoodAnalyzer(message);
MoodAnalyserFactory factory = new MoodAnalyserFactory();
object obj = factory.CreateMoodAnalyzerObject("MoodAnalyzerProblem.MoodAnalyzer", "MoodAnalyzer");
moodAnalyser.Equals(obj);
}
catch (MoodAnalyserException ex)
{
Assert.AreEqual(expected, ex.Message);
}
}
public void Given_Improper_Constructor_Name_Should_Throw_MoodAnalysisException_For_Parameterized_Constructor()
{
try
{
//Arrange
string className = "MoodAnalyzerProblem.MoodAnalyser";
string constructorName = "WrongConstructorName";
MoodAnalyser expectedObj = new MoodAnalyser("HAPPY");
//Act
object resultObj = MoodAnalyserFactory.CreateMoodAnalyserObjectUsingParametzisedConstructor(className, constructorName, "HAPPY");
}
catch (MoodAnalysisException e)
{
//Assert
Assert.AreEqual("constructor not found.", e.Message);
}
}
public void CheckForMethodNotFoundWithDefaultConstructor()
{
try
{
MoodAnalyserFactory <MoodAnalyser> moodFact = new MoodAnalyserFactory <MoodAnalyser>();
var returnObject = moodFact.GetConstructor();
ConstructorInfo mood = null;
var constructor = moodFact.GetInstance("MoodAnalyser", mood);
}
catch (MoodAnalyser.MoodAnalysisException exception)
{
Assert.AreEqual("No such method found", exception.Message);
}
catch (Exception e)
{
Assert.AreEqual("No such class found", e.Message);
}
}
public void GivenMoodAnalyserClassImproper_ShouldReturnThrowException_WithDefaultConstructor()
{
object expected = "Please enter valid Class";
// create object for moodanalyserfactory and get default constructor of class MoodAnalyser
MoodAnalyserFactory <MoodAnalyser> object_mood = new MoodAnalyserFactory <MoodAnalyser>();
ConstructorInfo constructorInfo = object_mood.GetConstructor();
try
{
// create instace for MoodAnalyser by calling GetInstance Method
object object_compare = object_mood.GetInstance("DemoClass", constructorInfo);
expected.Equals(object_compare);
}
catch (MoodAnalyserException exception)
{
Assert.AreEqual(expected, exception.Message);
}
}
public void TestingReflectionToChangeMoodMessageDynamically_TC7_3()
{
string expected = "Happy";
string actual = "";
try
{
actual = MoodAnalyserFactory.SetField("message", null);
}
catch (MoodAnalyserCustomException m)
{
actual = m.Message;
}
finally
{
Assert.AreEqual(expected, actual);
}
}
public void Given_MoodAnalyzer_Using_Reflection_Return_ParameterConstructor() //Method
{
string message = "I am in happy mood";
MoodAnalyzer expected = new MoodAnalyzer("I am in happy mood"); //Create object and arrange
object obj = null;
//string actual = "";
// string expected = "Mood should not be empty";
try
{
MoodAnalyserFactory factory = new MoodAnalyserFactory();
obj = factory.CreateMoodAnalyzerParameterObject("MoodAnalyzerProblem.MoodAnalyzer", "MoodAnalyzer", message);
}
catch (MoodAnalyserException exception)
{
}
obj.Equals(expected);
}
public void GivenMoodAnalyserClassNameShouldReturn_MoodAnalyserObject_TC_4_3()
{
object expected = null;
object actual = null;
try
{
expected = new MoodAnalyser();
actual = MoodAnalyserFactory.CreateMoodAnalyser("MoodAnalyzer.MoodAnalyser", "ModAnalyser");
}
catch (MoodAnalyserCustomException m)
{
Console.WriteLine(m.Message);
}
finally
{
expected.Equals(actual);
}
}
public void GivenMoodAnalyserClassNameShouldReturn_MoodAnalyserObject_UsingParameterizedConstructor_TC5_3()
{
object expected = null;
object actual = null;
try
{
expected = new MoodAnalyser("Happy");
actual = MoodAnalyserFactory.CreateMoodAnalyser_ParameterizedConstructor("MoodAnalyzer.MoodAnalyser", "MdAnalyser", "Happy");
}
catch (MoodAnalyserCustomException m)
{
Console.WriteLine(m.Message);
}
finally
{
expected.Equals(actual);
}
}
public void TestingMethodsCalledThroughReflection_6_2()
{
object actual = null;
object expected = null;
try
{
expected = "Happy Mood";
actual = MoodAnalyserFactory.InvokeAnalyseMethod("Analyse", "I am in Happy Mood");
}
catch (MoodAnalyserCustomException e)
{
actual = e.Message;
}
finally
{
Assert.AreEqual(expected, actual);
}
}
public void MoodAnalyseClass_GivenWrongClassName_ShouldReturn_NoClassException_UsingParameterizedConstrucor()
{
string expected = "Class not found";
object obj = null;
try
{
string message = "Happy";
object moodAnalyser = new MoodAnalyzer(message);
MoodAnalyserFactory factory = new MoodAnalyserFactory();
obj = factory.CreateMoodAnalyzerParameterObject("MoodAnalyzerProblem.MoodAnalyzer", "MoodAnalyzer", message);
moodAnalyser.Equals(obj);
}
catch (MoodAnalyserException ex)
{
Assert.AreEqual(expected, ex.Message);
}
}
public void GivenMoodAnalyser_ShouldReturnMoodAnalyser_WithDefaultConstructor()
{
object expected = new MoodAnalyser();
// create object for MoodAnalyserFactory and get default constructor of class MoodAnalyser
MoodAnalyserFactory <MoodAnalyser> object_mood = new MoodAnalyserFactory <MoodAnalyser>();
ConstructorInfo constructorInfo = object_mood.GetConstructor();
try
{
// create instace for MoodAnalysis by calling GetInstance Method
object object_compare = object_mood.GetInstance("MoodAnalyser", constructorInfo);
//Assert.AreEqual(new MoodAnalyser(), obj_compare);
expected.Equals(object_compare);
}
catch (MoodAnalyserException exception)
{
Assert.AreEqual(expected, exception.Message);
}
}
public void GivenMoodAnalyserClassAndConstructorImproper_ReturnThrowException_WithParameterizedConstructor()
{
object expected = "No such Method Found";
// create object for moodfactory and get default constructor of class MoodAnalyser
MoodAnalyserFactory <MoodAnalyser> object_mood = new MoodAnalyserFactory <MoodAnalyser>();
ConstructorInfo constructorInfo = object_mood.GetConstructor(1);
string message = "I am in Sad Mood";
try
{
// create instace for MoodAnalyser by calling GetInstance Method
object object_compare = object_mood.GetParameterizedInsatance("DemoMethod", constructorInfo, message);
expected.Equals(object_compare);
}
catch (MoodAnalyserException exception)
{
Assert.AreEqual(expected, exception.Message);
}
}
public void GivenWrongMethodShouldThrowException()
{
Assert.Throws <MoodAnalyserCustomException>(() => MoodAnalyserFactory.InvokeAnalyseMethod("Happy", "AnalyseMood2"));
}
public void ChangeMoodDynamically_WhenHappyMessage_ShouldReturnHappy()
{
dynamic result = MoodAnalyserFactory.ChangeMoodDynamically("MoodAnalyser.MoodAnalyserMain", "HAPPY");
Assert.AreEqual("HAPPY", result);
}
public void GivenHappyMessage_WithImproperFieldReflector_ShouldThrowException()
{
Assert.Throws <MoodAnalyserCustomException>(() => MoodAnalyserFactory.SetField("HAPPY", "message2"));
}
public void GivenHappyMessageInMethod_WhenProper_ShouldReturnHAPPY()
{
string moodAnalyserFactory = MoodAnalyserFactory.MethodInvokeUsingReflaction("Mood", "Happy Mood");
Assert.AreEqual("HAPPY", moodAnalyserFactory);
}
public void GivenHappyMessageInMethod_WhenFieldNameProper_ShouldReturnHAPPY()
{
string moodAnalyserFactory = MoodAnalyserFactory.SetFieldUsingReflection("Mood", "myString", "Happy Mood");
Assert.AreEqual("HAPPY", moodAnalyserFactory);
}
public void GivenHappyMessage_UsingReflection_IfCorrect_Should_ReturnHappy()
{
string message = MoodAnalyserFactory.InvokeMethod("MoodAnalyzer.MoodAnalyser", "GetMood", "HAPPY");
Assert.AreEqual("HAPPY", message);
}
public void GivenHappyMessageWithReflectorShouldReturnHappy()
{
string result = MoodAnalyserFactory.SetField("HAPPY", "message");
Assert.AreEqual("HAPPY", result);
}
