public void TestTooFewArgumentValues()
{
SimpleFormatter fmt = SimpleFormatter.Compile(
"Templates {2}{1} and {4} are out of order.");
try
{
fmt.Format("freddy", "tommy", "frog", "leg");
fail("Expected IllegalArgumentException");
}
catch (ArgumentException e)
{
// Expected
}
try
{
fmt.FormatAndAppend(
new StringBuilder(), null, "freddy", "tommy", "frog", "leg");
fail("Expected IllegalArgumentException");
}
catch (ArgumentException e)
{
// Expected
}
try
{
fmt.FormatAndReplace(
new StringBuilder(), null, "freddy", "tommy", "frog", "leg");
fail("Expected IllegalArgumentException");
}
catch (ArgumentException e)
{
// Expected
}
}
public void RadiusChangeOutput_InterparticleDistance_Spectrum()
{
// Arrange
GnuPlot gp = null;
var radius1 = 20;
var radiuses = new List <double> {
4, 10, 15, 20
};
double distance = 70;
string dirAzimuth45 = "RadiusChangeOutput_InterparticleDistance_Spectrum";
//foreach (var radius1 in radiuses)
//{
gp = new GnuPlot();
setLineStyle(gp);
gp.HoldOn();
setColorPalette(gp);
gp.Set(String.Format("title \"{0}\"", radius1));
foreach (double radius in radiuses)
{
Dictionary <double, double> azim45 = SimpleFormatter.Read(
this.getFileFormatDiffRadiuses(dirAzimuth45, distance, radius1, radius))
.ToDictionary(x => x.Key * 1e9, x => x.Value);
gp.Plot(azim45, string.Format(@"title ""{0}""", radius));
//gp.Clear();
}
//}
gp.Wait();
}
public void RadiusChangeOutput_Azimuth_Spectrum()
{
// Arrange
const int DistanceMax = 3;
const double DistanceStep = 0.1;
var radius1 = 4;
var radiuses = new List <double> {
4, 10, 20, 40, 70, 100, 200
};
List <double> distances = getDistances(DistanceStep, DistanceMax);
string dirAzimuth45 = "RadiusChangeOutput_Azimuth45";
var gp = new GnuPlot();
gp.Set("style data lines");
gp.HoldOn();
foreach (double radius in radiuses)
{
Dictionary <decimal, List <double> > spectrum = this.zipToDictionaryDiffRadiuses(distances, dirAzimuth45, radius1, radius);
string filename = Path.Combine(BasePath, this.TestContext.TestName, "Azim45.txt");
SimpleFormatter.WriteDictionary(filename, spectrum, distances);
foreach (double distance in distances.Take(5))
{
Dictionary <double, double> azim45 = SimpleFormatter.Read(
this.getFileFormatDiffRadiuses(dirAzimuth45, distance, radius1, radius));
gp.Plot(azim45, string.Format(@"title ""{0}""", radius));
}
gp.Clear();
}
gp.Wait();
}
public void TestWithArguments()
{
SimpleFormatter fmt = SimpleFormatter.Compile(
"Templates {2}{1} and {4} are out of order.");
assertEquals(
"getArgumentLimit",
5,
fmt.ArgumentLimit);
assertEquals(
"toString",
"Templates {2}{1} and {4} are out of order.",
fmt.ToString());
int[] offsets = new int[6];
assertEquals(
"format",
"123456: Templates frogtommy and {0} are out of order.",
fmt.FormatAndAppend(
new StringBuilder("123456: "),
offsets,
"freddy", "tommy", "frog", "leg", "{0}").ToString());
int[] expectedOffsets = { -1, 22, 18, -1, 32, -1 };
verifyOffsets(expectedOffsets, offsets);
}
public void TestMissingFieldMessage()
{
TestMessage message = new TestMessage("Param1", "Param2");
IMessageFormatter formatter = new SimpleFormatter();
Assert.Equal("First parameter is Param1. Second parameter is Param2.", formatter.Format(message));
}
public void AreClose_Azimuth45_AzimuthSum_EffectiveCrossExt()
{
// Arrange
const int DistanceMax = 3;
const double DistanceStep = 0.1;
var radiuses = new List <double> {
4, 10, 20, 40, 70, 100, 200
};
List <double> distances = getDistances(DistanceStep, DistanceMax);
string dirAzimuthSum = "RadiusDistanceOutput_AzimuthSum_EffectiveCrossExt";
string dirAzimuth45 = "RadiusDistanceOutput_Azimuth45_EffectiveCrossExt";
foreach (double radius in radiuses)
{
foreach (double distance in distances)
{
Dictionary <double, double> azim45 = SimpleFormatter.Read(
this.getFileFormat(dirAzimuth45, distance, radius));
Dictionary <double, double> azimSum = SimpleFormatter.Read(
this.getFileFormat(dirAzimuthSum, distance, radius));
AssertHelper.DictionaryAreClose(azim45, azimSum, 0.1);
}
}
}
public void RadiusDistanceOutput_AzimuthSum_EffectiveCrossExt()
{
// Arrange
const int DistanceMax = 3;
const double DistanceStep = 0.1;
var radiuses = new List <double> {
4, 10, 20, 40, 70, 100, 200
};
List <double> distances = getDistances(DistanceStep, DistanceMax);
string dirAzimuth0 = "RadiusDistanceOutput_Azimuth0_EffectiveCrossExt";
string dirAzimuth90 = "RadiusDistanceOutput_Azimuth90_EffectiveCrossExt";
// Calculate
foreach (double radius in radiuses)
{
foreach (double distance in distances)
{
Dictionary <double, double> azim0 = SimpleFormatter.Read(
this.getFileFormat(dirAzimuth0, distance, radius));
Dictionary <double, double> azim90 = SimpleFormatter.Read(
this.getFileFormat(dirAzimuth90, distance, radius));
Dictionary <double, double> azimSum = azim0.Zip(
azim90,
(x, y) =>
new KeyValuePair <double, double>(x.Key, (x.Value + y.Value) / 2))
.ToDictionary(key => key.Key, value => value.Value);
string filename = this.getFileFormat(this.TestContext.TestName, distance, radius);
SimpleFormatter.Write(filename, azimSum);
}
}
this.writeParameters(radiuses, distances);
}
private void calculateOneStepDiffRadius(
double radius1,
double radius2,
double distance,
double maxRadius,
Func <SimulationResult, double> valueSelector)
{
var firstPoint = new CartesianCoordinate(maxRadius, maxRadius, 0);
double secondPointCoord = maxRadius + 2 * radius1 + distance * radius2;
var secondPoint = new CartesianCoordinate(maxRadius, secondPointCoord, 0);
var systConfig = new SystemConfig(
new List <double>
{
radius1,
radius2
},
new List <CartesianCoordinate>
{
firstPoint,
secondPoint
});
SimulationResultDictionary result = DDAProgram.Calculate(this.ddaConfig, systConfig, this.opticalConstants);
string filename = this.getFileFormatDiffRadiuses(this.TestContext.TestName, distance, radius1, radius2);
SimpleFormatter.Write(
filename,
result.ToDictionary(x => x.ToType(SpectrumUnitType.WaveLength), valueSelector));
}
public static void Main()
{
IFormatter formatter = new SimpleFormatter();
IAppender appender = new ConsoleAppender(formatter);
ILogger logger = new Logger(appender);
IList <string> users = new List <string>();
users.Add("Pesho");
users.Add("Gosho");
users.Add("Stamat");
users.Add("Bate Goiko");
users.Add("Pablo Escobar");
users.Add("Osvaldo Rios");
IList <string> ignoredUsers = new List <string>();
foreach (var user in users)
{
if ((string)user == "Stamat")
{
ignoredUsers.Add(user);
}
else
{
logger.Info(string.Format("User {0} successfully registered", user));
}
}
foreach (var ignUser in ignoredUsers)
{
logger.Error(string.Format("Error for {0} registration", ignUser));
}
}
public void AreClose_Azimuth45_AzimuthSum()
{
// Arrange
const int DistanceMax = 3;
const double DistanceStep = 0.1;
var radiuses = new List <double> {
4, 10, 20, 40, 70, 100, 200
};
List <double> distances = getDistances(DistanceStep, DistanceMax);
string dirAzimuthSum = "RadiusDistanceOutput_AzimuthSum";
string dirAzimuth45 = "RadiusDistanceOutput_Azimuth45";
var gp = new GnuPlot();
setLineStyle(gp);
foreach (double radius in radiuses)
{
foreach (double distance in distances)
{
Dictionary <double, double> azim45 = SimpleFormatter.Read(
this.getFileFormat(dirAzimuth45, distance, radius));
Dictionary <double, double> azimSum = SimpleFormatter.Read(
this.getFileFormat(dirAzimuthSum, distance, radius));
gp.HoldOn();
gp.Plot(azim45);
gp.Plot(azimSum);
gp.HoldOff();
AssertHelper.DictionaryAreClose(azim45, azimSum, 0.5);
}
}
}
public void AreClose_Radius40_OpticalConst_DrudeLorentz()
{
// Arrange
const double DistanceMax = 0.5;
const double DistanceStep = 0.1;
List <double> distances = getDistances(DistanceStep, DistanceMax);
var radius = 40;
string dirOpticalConst = "RadiusDistanceOutput_Azimuth45_EffectiveCrossExt";
string dirDrudeLorentz = "RadiusDistanceDrudeLorentz_Azimuth45_EffectiveCrossExt";
var gp = new GnuPlot();
setLineStyle(gp);
gp.HoldOn();
foreach (double distance in distances)
{
Dictionary <double, double> optical = SimpleFormatter.Read(
this.getFileFormat(dirOpticalConst, distance, radius));
Dictionary <double, double> drudeLorentz = SimpleFormatter.Read(
this.getFileFormat(dirDrudeLorentz, distance, radius));
gp.Plot(optical, @"title ""optical""");
gp.Plot(drudeLorentz, @"title ""drude-lorentz""");
//AssertHelper.DictionaryAreClose(optical, drudeLorentz, 0.1);
}
gp.Wait();
}
public void AreCloseDistance3_OpticalConst_DrudeLorentz()
{
// Arrange
var distance = 2.9;
var radiuses = new List <double> {
4, 10, 20, 40, 70, 100, 200
};
string dirOpticalConst = "RadiusDistanceOutput_Azimuth45_EffectiveCrossExt";
string dirDrudeLorentz = "RadiusDistanceDrudeLorentz_Azimuth45_EffectiveCrossExt";
var gp = new GnuPlot();
setLineStyle(gp);
gp.HoldOn();
foreach (double radius in radiuses)
{
Dictionary <double, double> optical = SimpleFormatter.Read(
this.getFileFormat(dirOpticalConst, distance, radius));
Dictionary <double, double> drudeLorentz = SimpleFormatter.Read(
this.getFileFormat(dirDrudeLorentz, distance, radius));
gp.Plot(optical, @"title ""optical""");
gp.Plot(drudeLorentz, @"title ""drude-lorentz""");
//AssertHelper.DictionaryAreClose(optical, drudeLorentz, 0.1);
}
gp.Wait();
}
public void DimmerVsOne_Azimuth45_EffectiveCrossExt()
{
// Arrange
var radiuses = new List <double> {
4, 10, 20, 40
};
var distance = 0;
string dirAzimuth45 = "DimmerVsOne_Azimuth45_EffectiveCrossExt";
string dirAzimOne = "OneParticle_EffectiveCrossExt";
foreach (double radius in radiuses)
{
var gp = new GnuPlot();
setLineStyle(gp);
gp.HoldOn();
Dictionary <double, double> azim45 = SimpleFormatter.Read(
this.getFileFormat(dirAzimuth45, distance, radius))
.Where(x => x.Key <= 500)
.ToDictionary(x => x.Key * 1e9, x => x.Value * 2);
gp.Plot(azim45, string.Format(@"title ""{0}""", distance));
Dictionary <double, double> azimOne = SimpleFormatter.Read(
this.getFileFormatOneParticle(dirAzimOne, radius))
.Where(x => x.Key <= 500)
.ToDictionary(x => x.Key * 1e9, x => x.Value * 2);
gp.Plot(azimOne, string.Format(@"title ""{0}""", 0));
}
}
static void Main()
{
//TODO: replace this test data with the real data
var ben = new Programmer("Ben");
ben.Skills.Add(Skills.CSharp);
ben.Skills.Add(Skills.Java);
var adrian = new Programmer("Adrian");
adrian.Skills.Add(Skills.CSharp);
adrian.Skills.Add(Skills.Ruby);
ben.Recommendations.Add(adrian);
var programmers = new List <Programmer>()
{
adrian,
ben
};
var formatter = new SimpleFormatter();
var report = formatter.Format(programmers);
Console.Write(report);
Console.ReadLine();
}
public void TestThat_diplays_header_given_empty_list_of_developers()
{
var simpleFormatter = new SimpleFormatter();
var report = simpleFormatter.Format(new List<Programmer>());
Assert.AreEqual(SimpleFormatter.header, report);
}
public void TestThat_diplays_header_given_empty_list_of_developers()
{
var simpleFormatter = new SimpleFormatter();
var report = simpleFormatter.Format(new List <Programmer>());
Assert.AreEqual(SimpleFormatter.header, report);
}
public void TestGetTextWithNoArguments()
{
assertEquals(
"",
"Templates and are here.",
SimpleFormatter.Compile(
"Templates {1}{2} and {3} are here.").GetTextWithNoArguments());
}
static void Main(string[] args)
{
IFormater formetter = new SimpleFormatter();
IAppender appender = new FileAppender("file.txt",formetter);
Logger logger = new Logger(appender);
logger.Critical("Out of Memmory");
logger.Info("Unused local Variable");
}
public static void Main()
{
var simpleFormatter = new SimpleFormatter();
var appender = new FileAppender();
appender.Formatter = simpleFormatter;
appender.Append("Hello!");
}
static void Main(string[] args)
{
IFormater formetter = new SimpleFormatter();
IAppender appender = new FileAppender("file.txt", formetter);
Logger logger = new Logger(appender);
logger.Critical("Out of Memmory");
logger.Info("Unused local Variable");
}
public void TestBigArgument()
{
SimpleFormatter fmt = SimpleFormatter.Compile("a{20}c");
assertEquals("{20} count", 21, fmt.ArgumentLimit);
ICharSequence[] values = new ICharSequence[21];
values[20] = "b".AsCharSequence();
assertEquals("{20}=b", "abc", fmt.Format(values));
}
public void TestQuotingLikeMessageFormat()
{
string pattern = "{0} don't can''t '{5}''}{a' again '}'{1} to the '{end";
SimpleFormatter spf = SimpleFormatter.Compile(pattern);
MessageFormat mf = new MessageFormat(pattern, UCultureInfo.InvariantCulture);
String expected = "X don't can't {5}'}{a again }Y to the {end";
assertEquals("MessageFormat", expected, mf.Format(new Object[] { "X", "Y" }));
assertEquals("SimpleFormatter", expected, spf.Format("X", "Y"));
}
public void TestFormatReplaceNoOptimizationNoOffsets()
{
SimpleFormatter fmt = SimpleFormatter.Compile(
"Arguments {0} and {1}");
StringBuilder result = new StringBuilder("previous:");
assertEquals(
"",
"Arguments previous: and frog",
fmt.FormatAndReplace(result, null, result.ToString(), "frog").ToString());
}
/// <summary>
/// Mains the specified arguments.
/// </summary>
/// <param name="args">The arguments.</param>
public static void Main(string[] args)
{
var result = Calculate();
SimpleFormatter.Write(
"rezult_ext.txt",
result.ToDictionary(
x => x.Key.ToType(SpectrumUnitType.WaveLength),
x => x.Value.CrossSectionExtinction));
new SpectrumPlotter().Plot(result);
}
public void RadiusChangeOutputPeaks_Azimuth0_Azimuth90()
{
// Arrange
const int DistanceMax = 3;
const double DistanceStep = 0.1;
var radiuses = new List <double> {
4, 10, 20, 40, 70, 100, 200
};
var radius1 = 4;
List <double> distances = getDistances(DistanceStep, DistanceMax);
string dirAzimuth0 = "RadiusChangeOutput_Azimuth0";
string dirAzimuth90 = "RadiusChangeOutput_Azimuth90";
var gp = new GnuPlot();
gp.Set("style data lines");
gp.HoldOn();
radiuses.Reverse();
foreach (double radius in radiuses)
{
var peaks0 = new Dictionary <double, double>();
var peaks90 = new Dictionary <double, double>();
foreach (double distance in distances)
{
Dictionary <double, double> azim0 = SimpleFormatter.Read(
this.getFileFormatDiffRadiuses(dirAzimuth0, distance, radius1, radius));
Dictionary <double, double> azim90 = SimpleFormatter.Read(
this.getFileFormatDiffRadiuses(dirAzimuth90, distance, radius1, radius));
peaks0.Add(distance, azim0.MaxPair().Key);
peaks90.Add(distance, azim0.MaxPair().Key);
}
// gp.HoldOn();
// gp.Set(string.Format("terminal win {0}", radius));
gp.Plot(peaks0);
gp.Plot(peaks90);
// gp.HoldOff();
string basepath = Path.Combine(BasePath, this.TestContext.TestName);
string filename0 = Path.Combine(
basepath,
string.Format("peaks_0deg_{0}.txt", radius));
SimpleFormatter.Write(filename0, peaks0);
string filename90 = Path.Combine(
basepath,
string.Format("peaks_90deg_{0}.txt", radius));
SimpleFormatter.Write(filename90, peaks90);
}
gp.Wait();
}
public void Calculate_Success()
{
// Arrange
var filename = "../../rezult_ext.txt";
var dict = SimpleFormatter.Read(filename);
// Act
var result = DDAProgram.Calculate().ToDictionary(x => x.ToType(SpectrumUnitType.WaveLength), x => x.CrossSectionExtinction);
// Assert
AssertHelper.DictionaryAreClose(dict, result, 0.01);
}
public void TestFormatReplaceOptimizationNoOffsets()
{
SimpleFormatter fmt = SimpleFormatter.Compile("{2}, {0}, {1} and {3}");
StringBuilder result = new StringBuilder("original");
assertEquals(
"format",
"original, freddy, frog and by",
fmt.FormatAndReplace(
result,
null,
"freddy", "frog", result.ToString(), "by").ToString());
}
static void Main(string[] args)
{
var simpleFormatter = new SimpleFormatter();
var xmlFormatter = new XmlFormatter();
var jsonFormatter = new JSONFormatter();
var consoleAppender = new ConsoleAppender(xmlFormatter);
var fileAppender = new FileAppender(xmlFormatter, "log.txt");
Logger logger = new Logger(consoleAppender, fileAppender);
logger.Critical("Out of memory!");
logger.Info("Unused local variable 'name'");
fileAppender.Close();
}
public void TestThat_diplays_a_single_programmer()
{
var simpleFormatter = new SimpleFormatter();
var adrian = new Programmer("Adrian");
var programmer = new Programmer("Ben");
programmer.Skills.Add(Skills.CSharp);
programmer.Recommendations.Add(adrian);
var report = simpleFormatter.Format(new[] {programmer});
StringAssert.Contains("Ben", report);
StringAssert.Contains("CSharp", report);
StringAssert.Contains("Adrian", report);
}
public MainWindow()
{
this.InitializeComponent();
var simpleFormatter = new SimpleFormatter();
ListBox listBox = (ListBox)this.FindName("ListBox");
var listBoxAppender = new ListBoxAppender(simpleFormatter, listBox);
var fileAppender = new FileAppender(simpleFormatter, "simple.txt");
this.logger = new Logger(fileAppender, listBoxAppender);
this.KeyDown += this.MainWindow_KeyDown;
}
public void TestThat_diplays_a_single_programmer()
{
var simpleFormatter = new SimpleFormatter();
var adrian = new Programmer("Adrian");
var programmer = new Programmer("Ben");
programmer.Skills.Add(Skills.CSharp);
programmer.Recommendations.Add(adrian);
var report = simpleFormatter.Format(new[] { programmer });
StringAssert.Contains("Ben", report);
StringAssert.Contains("CSharp", report);
StringAssert.Contains("Adrian", report);
}
[TestMethod]//todo
public void RadiusChangeOutput_Azimuth_Spectrum()
{
// Arrange
const int DistanceMax = 3;
const double DistanceStep = 0.5;
GnuPlot gp = null;
var radius1 = 4;
var radiuses = new List <double> {
4, 10, 20, 40
};
List <double> distances = getDistances(DistanceStep, DistanceMax);
string dirAzimuth45 = "RadiusChangeOutput_Azimuth45_EffectiveExtinction";
string dirAzimuthOne = "OneParticle_EffectiveCrossExt";
//foreach (var radius1 in radiuses)
//{
gp = new GnuPlot();
setLineStyle(gp);
foreach (double distance in distances)
{
gp.HoldOn();
//gp.Set(String.Format("title \"{0}\"", radius1));
foreach (double radius in radiuses)
{
//Dictionary<decimal, List<double>> spectrum = this.zipToDictionaryDiffRadiuses(distances,
// dirAzimuth45, radius1, radius);
//string filename = Path.Combine(BasePath, this.TestContext.TestName, "Azim45.txt");
//SimpleFormatter.WriteDictionary(filename, spectrum, distances);
Dictionary <double, double> azim45 = SimpleFormatter.Read(
this.getFileFormatDiffRadiuses(dirAzimuth45, distance, radius1, radius)).Where(x => x.Key <= 500).ToDictionary(x => x.Key * 1e9, x => x.Value);
gp.Plot(azim45, string.Format(@"title ""{0}""", radius));
gp.Clear();
Dictionary <double, double> azim = SimpleFormatter.Read(
this.getFileFormatOneParticle(dirAzimuthOne, radius)).Where(x => x.Key <= 500).ToDictionary(x => x.Key * 1e9, x => x.Value);
gp.Plot(azim, @"title ""single""");
}
}
//}
gp.Wait();
}
public void TestFormatUseAppendToAsArgument()
{
SimpleFormatter fmt = SimpleFormatter.Compile(
"Arguments {0} and {1}");
StringBuilder appendTo = new StringBuilder("previous:");
try
{
fmt.FormatAndAppend(appendTo, null, appendTo.AsCharSequence(), "frog".AsCharSequence());
fail("IllegalArgumentException expected.");
}
catch (ArgumentException e)
{
// expected.
}
}
