StringExtensions IsFirstCharacterInLowerCase Method Delta Engine Documentation

Namespace: DeltaEngine.Extensions
Assembly: DeltaEngine (in DeltaEngine.dll) Version: 1.1.1.0 (1.1.1)
Syntax

public static bool IsFirstCharacterInLowerCase(
	this string word
)

Return Value

Type: Boolean

Usage Note

In Visual Basic and C#, you can call this method as an instance method on any object of type String. When you use instance method syntax to call this method, omit the first parameter. For more information, see Extension Methods (Visual Basic) or Extension Methods (C# Programming Guide).
Remarks

Tests: DeltaEngine.Tests.Extensions.StringExtensionsTests
Examples

2 unit tests call DeltaEngine.Extensions.StringExtensions.IsFirstCharacterInLowerCase(System.String)
    [Test]
    public void SplitIntoFloats()
    {
        var stringFloats = new[]
        { "1.0", "2.0", "0511.580254", Math.PI.ToString(CultureInfo.InvariantCulture) };
        var expectedFloats = new[] { 1.0f, 2.0f, 511.580261f, 3.14159274f };
        float[] floats = stringFloats.SplitIntoFloats();
        CollectionAssert.AreEqual(expectedFloats, floats);
    }

    [Test]
    public void SplitIntoFloatsWithSeparator()
    {
        const string StringFloats = "1.0, 2.0, 0511.580254";
        var expectedFloats = new[] { 1.0f, 2.0f, 511.580261f };
        CollectionAssert.AreEqual(expectedFloats, StringFloats.SplitIntoFloats(','));
        CollectionAssert.AreEqual(expectedFloats, StringFloats.SplitIntoFloats(", "));
    }

    [Test]
    public void Compare()
    {
        Assert.IsTrue("AbC1".Compare("aBc1"));
        Assert.IsTrue("1.23".Compare("1.23"));
        Assert.IsFalse("Hello".Compare("World"));
    }

    [Test]
    public void ContainsCaseInsensitive()
    {
        Assert.IsTrue("hallo".ContainsCaseInsensitive("ha"));
        Assert.IsTrue("1.23".ContainsCaseInsensitive("1.2"));
        Assert.IsTrue("Hello".ContainsCaseInsensitive("hel"));
        Assert.IsFalse("Banana".ContainsCaseInsensitive("Apple"));
        Assert.IsFalse(((String)null).ContainsCaseInsensitive("abc"));
    }

    [Test]
    public void IsFirstCharacterInLowerCase()
    {
        Assert.IsFalse("Banana".IsFirstCharacterInLowerCase());
        Assert.IsTrue("banana".IsFirstCharacterInLowerCase());
        Assert.IsTrue("".IsFirstCharacterInLowerCase());
    }

    [Test]
    public void ConvertFirstCharacterToUpperCase()
    {
        const string UpperCaseWord = "Banana";
        Assert.AreEqual(UpperCaseWord, UpperCaseWord.ConvertFirstCharacterToUpperCase());
        Assert.AreEqual(UpperCaseWord, "banana".ConvertFirstCharacterToUpperCase());
        Assert.AreEqual("", "".ConvertFirstCharacterToUpperCase());
    }

    [Test]
    public void SplitTextIntoWords()
    {
        var stringWords = "TestForSplittingAStringIntoWords".SplitWords(true);
        Assert.AreEqual(' ', stringWords[4]);
        Assert.AreEqual("Test for splitting a string into words", stringWords);
    }

    [Test]
    public void FromByteArray()
    {
        const string TestString = "TestString";
        Assert.AreEqual(TestString,
            StringExtensions.FromByteArray(StringExtensions.ToByteArray(TestString)));
    }

    [Test]
    public void StartsWith()
    {
        Assert.True(StringExtensions.StartsWith("Hi there, whattup?", "Hi"));
        Assert.False(StringExtensions.StartsWith("Hi there, whattup?", "what"));
        Assert.True(StringExtensions.StartsWith("bcdeuf", "bc"));
        Assert.False(StringExtensions.StartsWith("bcdeuf", "abc"));
        Assert.True("Hi there, whattup?".StartsWith(new[] { "Hi", "there", "what" }));
        Assert.False("Hi there, whattup?".StartsWith(new[] { "she", "there", "what" }));
        Assert.True(StringExtensions.StartsWith("ATI Radeon 9500+", "ati"));
        Assert.False(StringExtensions.StartsWith("A-t-i da gaga", "ati"));
        Assert.True(StringExtensions.StartsWith("NVidia Geforce3", "nvidia"));
    }

    [Test]
    public void SplitWordsWithEmptyWord()
    {
        const string TestString = "";
        Assert.AreEqual(TestString, TestString.SplitWords(true));
    }

    [Test]
    public void ConvertNotRecognizedType()
    {
        Assert.Throws<NotSupportedException>(() => "false,false".Convert<List<bool>>());
    }

    [Test]
    public void ConvertNullStringToDictionaryReturns()
    {
        const string ArrayOfStrings = null;
        var dictionary = ArrayOfStrings.Convert<Dictionary<string, string>>();
        Assert.IsInstanceOf<Dictionary<string, string>>(dictionary);
    }

    [Test]
    public void ConvertStringToDictionary()
    {
        const string ArrayOfStrings = "FirstKey;FirstValue;SecondKey;SecondValue";
        var dictionary = ArrayOfStrings.Convert<Dictionary<string, string>>();
        Assert.IsTrue(dictionary.ContainsKey("FirstKey"));
        Assert.IsTrue(dictionary.ContainsValue("SecondValue"));
    }

    [Test]
    public void ConvertDictionaryToString()
    {
        var dictionary = new Dictionary<string, string>();
        dictionary.Add("FirstKey","FirstValue");
        dictionary.Add("SecondKey","SecondValue");
        var arrayOfStrings = StringExtensions.ToInvariantString(dictionary);
        Assert.AreEqual(41, arrayOfStrings.Length);
        Assert.AreEqual(8, arrayOfStrings.IndexOf(';'));
        Assert.AreEqual(29, arrayOfStrings.LastIndexOf(';'));
    }

    [Test]
    public void CheckForCleanFileName()
    {
        Assert.AreEqual("", GetCleanFileName(null));
        Assert.AreEqual("", GetCleanFileName(""));
        Assert.AreEqual("", GetCleanFileName("   "));
        Assert.AreEqual("PureFilename", GetCleanFileName("PureFilename"));
        Assert.AreEqual("PureFilename", GetCleanFileName("Pure Filename"));
        Assert.AreEqual("FullFilename.ext", GetCleanFileName("FullFilename.ext"));
        Assert.AreEqual("File1.ext", GetCleanFileName("File#1.ext"));
        Assert.AreEqual("FileAB.ext", GetCleanFileName("FileA|B.ext"));
    }

    private static string GetCleanFileName(string filename)
    {
        return StringExtensions.GetFilenameWithoutForbiddenCharactersOrSpaces(filename);
    }
}
[Test]
public void IsFirstCharacterInLowerCase()
{
    Assert.IsFalse("Banana".IsFirstCharacterInLowerCase());
    Assert.IsTrue("banana".IsFirstCharacterInLowerCase());
    Assert.IsTrue("".IsFirstCharacterInLowerCase());
}
See Also