public void ShouldReverseString()
{
// Arrange
var someString = "Hello World!";
var modifier = new StringModifier();
// Act
var result = modifier.ReverseString(someString);
// Assert
Assert.AreEqual(result, "!dlroW olleH");
}
public static string ModifyString (string value, StringModifier modifier)
{
// German shouldn't convert to lowercase and uppercase.
if (modifier == StringModifier.None || CultureInfo.CurrentCulture.Name == "de-DE") {
return value;
}
switch (modifier) {
case StringModifier.Lowercase: return value.ToLower ();
case StringModifier.Uppercase: return value.ToUpper ();
default: return value;
}
}
public static List<Dictionary<string, string>> GetComments(int aCount, Int64 aArticleId, StringModifier aStringModifier)
{
List<Dictionary<string, string>> result = new List<Dictionary<string, string>>(aCount);
OleDbConnection dbConnection;
OleDbCommand dbCommand;
OleDbDataReader dbReader;
try
{
dbConnection = new OleDbConnection(ConnectionStringsManager.GetConnectionString());
dbCommand = new OleDbCommand(_SELECT_COMMENTS, dbConnection);
dbCommand.Parameters.Add(_COL2, OleDbType.BigInt).Value = aArticleId;
dbConnection.Open();
dbReader = dbCommand.ExecuteReader();
try
{
while (dbReader.Read())
{
Dictionary<string, string> commentNode = new Dictionary<string, string>(3);
// get comment's names
if (dbReader[_COL3] != null)
commentNode.Add("names", dbReader[_COL3].ToString());
// get comment's published
if (dbReader[_COL7] != null)
commentNode.Add("published", dbReader[_COL7].ToString());
// get comment's mid of MID(Comment, 1, 1000)
if (dbReader["SubContent"] != null)
commentNode.Add("Comment", aStringModifier(dbReader["SubContent"].ToString()));
result.Add(commentNode);
}
}
finally
{
dbConnection.Close();
dbReader.Close();
}
}
catch (Exception ex)
{
throw new Exception(ex.ToString());
}
return result;
}
private void StartBtn_Click(object sender, EventArgs e)
{
try
{
StringModifier revString = new StringModifier(InputText.Text);
ResultText.Text = revString.StrReverse();
}
catch (Exception exc)
{
MessageBsc.ShowError(exc.Message);
}
}
static void ReadWrite(StringModifier modifier, string reader, string writer)
{
StreamReader input = new StreamReader(reader);
StreamWriter output = new StreamWriter(writer);
string line;
while ((line = input.ReadLine()) != null)
{
//Console.WriteLine(CapsFirst(line));
output.WriteLine(modifier(line));
}
input.Close();
output.Close();
}
private List <List <string> > FilterEveryWordSet()
{
var eachWordSetOutput = new List <List <string> >();
foreach (var s in _input)
{
var circularlyShiftedSingle = StringModifier.CircularlyShift(new List <string> {
s
});
eachWordSetOutput.Add(StringModifier.Alphabetize(circularlyShiftedSingle));
}
return(eachWordSetOutput);
}
public static List<Dictionary<string, string>> GetArticles(int aCount, StringModifier aStringModifier)
{
List<Dictionary<string, string>> result = new List<Dictionary<string, string>>(aCount);
OleDbConnection dbConnection;
OleDbCommand dbCommand;
OleDbDataReader dbReader;
try
{
dbConnection = new OleDbConnection(ConnectionStringsManager.GetConnectionString());
dbCommand = new OleDbCommand(_SELECT_ARTICLES, dbConnection);
dbConnection.Open();
dbReader = dbCommand.ExecuteReader();
try
{
while (dbReader.Read())
{
Dictionary<string, string> articleNode = new Dictionary<string, string>(3);
// get article's ID
if (dbReader[_COL1] != null)
articleNode.Add("ID", dbReader[_COL1].ToString());
// get article's title
if (dbReader[_COL1] != null)
articleNode.Add("Title", dbReader[_COL2].ToString());
// get article's mid of MID(Content, 1, 1000)
if (dbReader["SubContent"] != null)
articleNode.Add("Content", aStringModifier(dbReader["SubContent"].ToString()));
result.Add(articleNode);
}
}
finally
{
dbConnection.Close();
dbReader.Close();
}
}
catch (Exception ex)
{
throw new Exception(ex.ToString());
}
return result;
}
static void Main(string[] args)
{
Console.WriteLine("Enter a String: ");
string demo = Console.ReadLine();
Console.WriteLine(".....Creating as a String Builder.....");
StringBuilder sb = new StringBuilder(demo);
Console.WriteLine("Created a String Builder Mutable string: " + sb);
bool condition = true;
while (condition)
{
Console.WriteLine("Enter 0: To Exit\n1: Append\n2: Insert\n3: Remove\n4: Replace\n");
int choice = Convert.ToInt32(Console.ReadLine());
switch (choice)
{
case 0:
Console.WriteLine("Bye!");
condition = false;
break;
case 1:
StringModifier.AppendString(ref sb);
Console.WriteLine("\nNewly Appended string " + sb);
break;
case 2:
StringModifier.InsertString(ref sb);
Console.WriteLine("\nNewly Inserted string " + sb);
break;
case 3:
StringModifier.RemoveString(ref sb);
Console.WriteLine("\nNewly Remmoved string " + sb);
break;
case 4:
StringModifier.ReplaceString(ref sb);
Console.WriteLine("\nNewly Replaced string " + sb);
break;
} //end of switch
} //end of while
}
public void ReplaceOperationWithResult()
{
// Arrange
string CalculationString = "4+6/2*3-8";
string OperatorToCalculate = "/";
StringModifier SystemUnderTest = new StringModifier(_operationIdentifier.Object, _operationFactory.Object);
// Act
SystemUnderTest.SubstituteOperationsWithResult(ref CalculationString, OperatorToCalculate);
// Assert
CalculationString.ShouldBe("4+3*3-8");
_operationFactory.Verify(x => x.Create("6/2"), Times.Once());
_operator.Verify(x => x.GetResult(), Times.Once());
}
public void ReturnPositiveIfDoubleNegative()
{
// Arrange
string CalculationString = "--20";
string OperatorToCalculate = "-";
StringModifier SystemUnderTest = new StringModifier(_operationIdentifier.Object, _operationFactory.Object);
// Act
SystemUnderTest.SubstituteOperationsWithResult(ref CalculationString, OperatorToCalculate);
// Assert
CalculationString.ShouldBe("20");
_operationFactory.Verify(x => x.Create(It.IsAny <string>()), Times.Never());
_operator.Verify(x => x.GetResult(), Times.Never());
}
/// <summary>
/// Auto-generated argument string
/// </summary>
public string GetArgsString()
{
var ops = new List <string>();
foreach (FieldInfo item in this.GetType().GetFields())
{
var atts = item.CustomAttributes;
bool hasIt = atts.ToList().Exists(n => n.AttributeType == typeof(OptionAttribute));
if (hasIt)
{
string optionName = item.Name;
string value = (string)item.GetValue(this);
string surroundedValue = StringModifier.SurroundWith("\"", value);
string op = $"-{optionName}:{surroundedValue}";
ops.Add(op);
}
}
string cmd = string.Join(" ", ops);
return(cmd);
}
public static void SetModifier(BindableObject bindable, StringModifier value)
{
bindable.SetValue(ModifierProperty, value);
}
public static void SetModifier(DependencyObject o, StringModifier value)
{
o.SetValue(ModifierProperty, value);
}
public static void SetModifier(DependencyObject o, StringModifier value)
{
o.SetValue (ModifierProperty, value);
}
public static string ModifyString(string value, StringModifier modifier)
{
// German shouldn't convert to lowercase and uppercase.
if (modifier == StringModifier.None || CultureInfo.CurrentCulture.Name == "de-DE") {
return value;
}
switch (modifier) {
case StringModifier.Lowercase: return value.ToLower ();
case StringModifier.Uppercase: return value.ToUpper ();
default: return value;
}
}
public static string GetString(string message,
StringModifier modifier = StringModifier.None,
string comment = null)
{
return ModifyString (Vernacular.Catalog.GetString (message), modifier);
}
public static string GetPluralString(string singularMessage, string pluralMessage, int n,
StringModifier modifier = StringModifier.None,
string comment = null)
{
return ModifyString (Vernacular.Catalog.GetPluralString (singularMessage, pluralMessage, n), modifier);
}
private List <string> FilterCombinedWordSet()
{
var circularlyShifted = StringModifier.CircularlyShift(_input);
return(StringModifier.Alphabetize(circularlyShifted));
}
/// <summary>
/// Exe file path surrounded by " charater
/// </summary>
public string GetExePath()
{
return(StringModifier.SurroundWith("\"", _exePath));
}
public static string GetString(string message,
StringModifier modifier = StringModifier.None,
string comment = null)
{
return(ModifyString(Vernacular.Catalog.GetString(message), modifier));
}
internal static IntPtr ProcessReal(IntPtr Target)
{
again :;
int Tries = 0;
try {
DateTime?Begin = DelayTest ? DateTime.Now : (DateTime?)null;
dynamic Ptr = ParsePtr(Target);
if (StrRld == null)
{
try {
Init();
Log("Initiallized", true);
} catch (Exception ex) {
PreserveStackTrace(ex);
throw ex;
}
Initialized = true;
}
if (Ptr == 0)
{
return(IntPtr.Zero);
}
#if DEBUG
if (LogAll)
{
Log("Target: {0} | Ptr: {1} | char.MaxValue {2} | Convert: {3}", true, Target.ToString(), Ptr, char.MaxValue, unchecked ((uint)Ptr));
}
#endif
if (!LiteMode)
{
if (Ptr <= char.MaxValue)
{
return(ProcessChar(Target));
}
if (CachePointers)
{
if (PtrCacheIn.Contains(Target))
{
return(PtrCacheOut[PtrCacheIn.IndexOf(Target)]);
}
}
}
if (IsBadCodePtr(Target) && Ptr >= char.MaxValue)
{
if (LogAll)
{
Log("BAD PTR: {0}", true, Ptr);
}
return(Target);
}
string Input = GetString(Target);
if (string.IsNullOrWhiteSpace(Input))
{
return(Target);
}
string Reloaded = StrMap(Input, Target, false);
LastInput = Input;
if (Input != Reloaded)
{
Reloaded = PostReload(Reloaded);
}
//Prevent inject a string already injected
if (Input == Reloaded)
{
return(Target);
}
DialogFound = true;
if (!LiteMode)
{
if (StringModifier != null)
{
try {
Reloaded = StringModifier.Call("Modifier", "ResultHook", Reloaded);
} catch {
Log("Result Hook Error...", true);
}
}
Reloaded = PrefixWorker(Reloaded);
CacheReply(Reloaded);
TrimWorker(ref Reloaded, Input);
if (NoReload)
{
return(Target);
}
if (LogAll || LogOutput)
{
if (AllowDuplicates)
{
Log("Output: {0}\r\nDB Current Index: {1}", true, Reloaded);
}
else
{
Log("Output: {0}", true, Reloaded);
}
}
}
IntPtr Output = GenString(Reloaded);
if (!LiteMode)
{
AddPtr(Output);
AddPtr(Target);
if (CachePointers)
{
CachePtr(Target, Output);
}
if (DelayTest)
{
Log("Delay - {0}ms", false, (DateTime.Now - Begin)?.TotalMilliseconds);
}
}
return(Output);
} catch (Exception ex) {
Error("Ops, a Bug...\n{0}\n======================\n{1}\n============================\n{2}\n============================\n{3}", ex.Message, ex.StackTrace, ex.Data, ex.Source);
if (Tries++ < 3)
{
goto again;
}
Initialized = true;
}
return(Target);
}
static void Main()
{
Character human = new Character("Vlad", 100, 100);
Event myEvent = new Event();
myEvent.MoveEvent += (x, y) => human.MoveCharacter(x, y);
myEvent.SqueezeEvent += s => human.ShrinkCharacter(s);
human.CharacterInfo();
myEvent.CallMove(3, 5);
human.CharacterInfo();
myEvent.CallSqueeze(3);
human.CharacterInfo();
StringModifier modifier;
StringModifier delPunctuationMark = s =>
{
string temp = "";
string marks = ",.:;-()";
bool isMark = false;
for (int i = 0; i < s.Length; i++)
{
isMark = false;
for (int j = 0; j < marks.Length; j++)
{
if (s[i] == marks[j])
{
isMark = true;
break;
}
}
if (isMark == false)
{
temp += s[i];
}
}
Console.WriteLine(temp);
return(temp);
};
StringModifier reverseString = s =>
{
string temp = " ";
for (int j = 0, i = s.Length - 1; i >= 0; i--, j++)
{
temp += s[i];
}
Console.WriteLine(temp);
return(temp);
};
StringModifier toUpper = s => s.ToUpper();
StringModifier delSpaces = s =>
{
string temp = "";
for (int i = 0; i < s.Length; i++)
{
if (s[i] != ' ')
{
temp += s[i];
}
}
Console.WriteLine(temp);
return(temp);
};
StringModifier replaceSpaces = s =>
{
Console.WriteLine(s.Replace(' ', '_'));
return(s.Replace(' ', '_'));
};
modifier = delPunctuationMark;
modifier += reverseString;
modifier += replaceSpaces;
modifier += delSpaces;
modifier += toUpper;
Console.WriteLine(modifier("строка , массив : событие ; лямбда-выражение . делегат )"));
}
public static string GetPluralString(string singularMessage, string pluralMessage, int n,
StringModifier modifier = StringModifier.None,
string comment = null)
{
return(ModifyString(Vernacular.Catalog.GetPluralString(singularMessage, pluralMessage, n), modifier));
}
public MasterMap()
{
_stringModifier = new StringModifier();
}
