public void TestTorznabConcat()
{
var torznabCaps1 = new TorznabCapabilities();
var torznabCaps2 = new TorznabCapabilities();
var res = TorznabCapabilities.Concat(torznabCaps1, torznabCaps2);
Assert.True(res.SearchAvailable);
Assert.IsEmpty(res.TvSearchParams);
Assert.IsEmpty(res.MovieSearchParams);
Assert.IsEmpty(res.MusicSearchParams);
Assert.IsEmpty(res.BookSearchParams);
Assert.IsEmpty(res.Categories);
torznabCaps1 = new TorznabCapabilities
{
SearchAvailable = false,
TvSearchParams = new List <TvSearchParam> {
TvSearchParam.Q
},
MovieSearchParams = new List <MovieSearchParam> {
MovieSearchParam.Q
},
MusicSearchParams = new List <MusicSearchParam> {
MusicSearchParam.Q
},
BookSearchParams = new List <BookSearchParam> {
BookSearchParam.Q
},
Categories = new List <TorznabCategory> {
TorznabCatType.Movies, new TorznabCategory(100001, "CustomCat1")
}
};
torznabCaps2 = new TorznabCapabilities
{
SearchAvailable = false,
TvSearchParams = new List <TvSearchParam> {
TvSearchParam.Season
},
MovieSearchParams = new List <MovieSearchParam> {
MovieSearchParam.ImdbId
},
MusicSearchParams = new List <MusicSearchParam> {
MusicSearchParam.Artist
},
BookSearchParams = new List <BookSearchParam> {
BookSearchParam.Title
},
Categories = new List <TorznabCategory> {
TorznabCatType.TVAnime, new TorznabCategory(100002, "CustomCat2")
}
};
res = TorznabCapabilities.Concat(torznabCaps1, torznabCaps2);
Assert.False(res.SearchAvailable);
Assert.True(res.TvSearchParams.Count == 2);
Assert.True(res.MovieSearchParams.Count == 2);
Assert.True(res.MusicSearchParams.Count == 2);
Assert.True(res.BookSearchParams.Count == 2);
Assert.True(res.Categories.Count == 3); // only CustomCat2 is removed
}
public void TestConstructor()
{
var tcc = new TorznabCapabilitiesCategories();
Assert.IsEmpty(tcc.GetTorznabCategories());
Assert.IsEmpty(tcc.GetTrackerCategories());
}
public void Receive2Inputs_Update_SpeedAndDirectionIsNaN()
{
//Create fake Plane with Invalid
IPlane invalidSpeedPlane = Substitute.For <IPlane>();
invalidSpeedPlane.Tag.Returns("TEST123");
invalidSpeedPlane.XCoordinate.Returns(10000);
invalidSpeedPlane.YCoordinate.Returns(10000);
invalidSpeedPlane.LastUpdate.Returns(CorrectDateTime);
invalidSpeedPlane.Speed.Returns(Double.NaN);
//Create fake Plane with Invalid Direction
IPlane invalidDirectionPlane = Substitute.For <IPlane>();
invalidDirectionPlane.Tag.Returns("TEST321");
invalidDirectionPlane.XCoordinate.Returns(10000);
invalidDirectionPlane.YCoordinate.Returns(10000);
invalidDirectionPlane.LastUpdate.Returns(CorrectDateTime);
invalidDirectionPlane.Direction.Returns(Double.NaN);
List <IPlane> planeWithNaNSpeed = new List <IPlane> {
invalidSpeedPlane, invalidDirectionPlane
};
//No planes were added to EmptyPlaneList because all planes that was to be added were invalid.
List <IPlane> emptyPlaneList = uut.GetCompletePlanes(planeWithNaNSpeed);
Assert.IsEmpty(emptyPlaneList);
}
public IEnumerator ItDoesntReceiveMessageForDifferentChannel()
{
CreateClient(ChannelParameterOne);
yield return(WaitForClientToSettle());
Assert.IsEmpty(client.receivedMessages);
yield return(OnFacet <BroadcastingFacet> .Call(
nameof(BroadcastingFacet.SendMyMessage),
ChannelParameterTwo, // TWO
"Send to another channel"
).AsCoroutine());
// send one message afterwards for which we can wait
yield return(OnFacet <BroadcastingFacet> .Call(
nameof(BroadcastingFacet.SendMyMessage),
ChannelParameterOne,
"Hello world!"
).AsCoroutine());
// wait for the one message
yield return(WaitForMessages(1));
// and check it's the hello-world one
Assert.AreEqual(1, client.receivedMessages.Count);
Assert.IsInstanceOf <MyMessage>(client.receivedMessages[0]);
Assert.AreEqual(
"Hello world!",
((MyMessage)client.receivedMessages[0]).foo
);
yield return(null);
}
public void TestConstructor()
{
var indexer = new TestWebIndexer();
var caps = indexer.TorznabCaps;
Assert.True(caps.SearchAvailable);
Assert.IsEmpty(caps.TvSearchParams);
Assert.False(caps.TvSearchAvailable);
Assert.False(caps.TvSearchSeasonAvailable);
Assert.False(caps.TvSearchEpAvailable);
Assert.False(caps.TvSearchImdbAvailable);
Assert.False(caps.TvSearchTvdbAvailable);
Assert.False(caps.TvSearchTvRageAvailable);
Assert.IsEmpty(caps.MovieSearchParams);
Assert.False(caps.MovieSearchAvailable);
Assert.False(caps.MovieSearchImdbAvailable);
Assert.False(caps.MovieSearchTmdbAvailable);
Assert.IsEmpty(caps.MusicSearchParams);
Assert.False(caps.MusicSearchAvailable);
Assert.False(caps.MusicSearchAlbumAvailable);
Assert.False(caps.MusicSearchArtistAvailable);
Assert.False(caps.MusicSearchLabelAvailable);
Assert.False(caps.MusicSearchYearAvailable);
Assert.IsEmpty(caps.BookSearchParams);
Assert.False(caps.BookSearchAvailable);
Assert.False(caps.BookSearchTitleAvailable);
Assert.False(caps.BookSearchAuthorAvailable);
Assert.AreEqual(0, caps.Categories.GetTorznabCategoryTree().Count);
}
public void TestConstructors()
{
// TODO: initialize MusicSearchAvailable
var torznabCaps = new TorznabCapabilities();
Assert.True(torznabCaps.SearchAvailable);
Assert.IsEmpty(torznabCaps.TvSearchParams);
Assert.False(torznabCaps.TvSearchAvailable);
Assert.False(torznabCaps.TvSearchSeasonAvailable);
Assert.False(torznabCaps.TvSearchEpAvailable);
Assert.False(torznabCaps.TvSearchImdbAvailable);
Assert.False(torznabCaps.TvSearchTvdbAvailable);
Assert.False(torznabCaps.TvSearchTvRageAvailable);
Assert.IsEmpty(torznabCaps.MovieSearchParams);
Assert.False(torznabCaps.MovieSearchAvailable);
Assert.False(torznabCaps.MovieSearchImdbAvailable);
Assert.False(torznabCaps.MovieSearchTmdbAvailable);
Assert.IsEmpty(torznabCaps.SupportedMusicSearchParamsList);
Assert.False(torznabCaps.MusicSearchAvailable); // init
Assert.False(torznabCaps.BookSearchAvailable);
Assert.IsEmpty(torznabCaps.Categories);
}
public void TestConstructors()
{
var torznabCaps = new TorznabCapabilities();
Assert.True(torznabCaps.SearchAvailable);
Assert.IsEmpty(torznabCaps.TvSearchParams);
Assert.False(torznabCaps.TvSearchAvailable);
Assert.False(torznabCaps.TvSearchSeasonAvailable);
Assert.False(torznabCaps.TvSearchEpAvailable);
Assert.False(torznabCaps.TvSearchImdbAvailable);
Assert.False(torznabCaps.TvSearchTvdbAvailable);
Assert.False(torznabCaps.TvSearchTvRageAvailable);
Assert.IsEmpty(torznabCaps.MovieSearchParams);
Assert.False(torznabCaps.MovieSearchAvailable);
Assert.False(torznabCaps.MovieSearchImdbAvailable);
Assert.False(torznabCaps.MovieSearchTmdbAvailable);
Assert.IsEmpty(torznabCaps.MusicSearchParams);
Assert.False(torznabCaps.MusicSearchAvailable);
Assert.False(torznabCaps.MusicSearchAlbumAvailable);
Assert.False(torznabCaps.MusicSearchArtistAvailable);
Assert.False(torznabCaps.MusicSearchLabelAvailable);
Assert.False(torznabCaps.MusicSearchYearAvailable);
Assert.IsEmpty(torznabCaps.BookSearchParams);
Assert.False(torznabCaps.BookSearchAvailable);
Assert.False(torznabCaps.BookSearchTitleAvailable);
Assert.False(torznabCaps.BookSearchAuthorAvailable);
Assert.IsEmpty(torznabCaps.Categories.GetTorznabCategoryTree());
Assert.IsEmpty(torznabCaps.Categories.GetTrackerCategories());
}
public void FailDivisionResultIsEmpty()
{
_firstNum = 25;
_secondNum = 2;
var result = Calc.Division(_firstNum, _secondNum).ToString();
Assert.IsEmpty(result, $"Result of division {_firstNum} and {_secondNum} is not empty");
}
public void TestInputParser_IncorrectHeadingOnly_HasEmptyParsedList()
{
const string incorrectHeading = "xyz,abc,def,ghi";
var inputParser = new InputParser();
Assert.IsEmpty(inputParser.ParseInput(new [] { incorrectHeading }));
Assert.IsEmpty(inputParser.InvalidInputRows);
}
public void FindByName_return_null_when_Exposition_with_name_not_found()
{
string name = "";
var result = _grafikService.FindByName(name);
Assert.IsEmpty(result);
}
public static void AssertLoadAasx(Application application, Window mainWindow, string path)
{
if (!File.Exists(path))
{
throw new InvalidOperationException($"The AASX file to be loaded does not exist: {path}");
}
var fileMenuItem = mainWindow
.FindFirstDescendant(
cf => cf.ByClassName("MenuItem").And(cf.ByName("File")))
.AsMenuItem();
fileMenuItem.Click();
var openMenuItem = fileMenuItem
.FindFirstChild(cf => cf.ByName("Open .."))
.AsMenuItem();
if (openMenuItem == null)
{
throw new AssertionException(
"The open menu item is null. You need to thoroughly inspect what happened -- " +
"this is quite strange.");
}
openMenuItem.Click();
Retry.WhileEmpty(
() => mainWindow.ModalWindows,
throwOnTimeout: true, timeout: TimeSpan.FromSeconds(10),
timeoutMessage: "Could not find the modal windows of the main window");
Assert.AreEqual(1, mainWindow.ModalWindows.Length);
var modal = mainWindow.ModalWindows[0];
var pathCombo = modal.FindFirstChild(cf => cf.ByAutomationId("1148")).AsComboBox();
pathCombo.EditableText = path;
var openButton = modal.FindFirstChild(cf => cf.ByAutomationId("1")).AsButton();
openButton.Click();
Assert.IsEmpty(modal.ModalWindows,
$"Unexpected modal window (probably an error) while opening the AASX: {path}");
Retry.WhileTrue(() => mainWindow.ModalWindows.Length > 0,
throwOnTimeout: true, timeout: TimeSpan.FromSeconds(10));
if (application.HasExited)
{
throw new AssertionException(
"The application unexpectedly exited. " +
$"Check manually why the file could not be opened: {path}");
}
}
public void TestInputParser_NoHeading_HasEmptyParsedList()
{
IList <string> inputTexts = new[]
{
"Comp,1990,1991,310"
};
var inputParser = new InputParser();
Assert.IsEmpty(inputParser.ParseInput(inputTexts));
Assert.IsEmpty(inputParser.InvalidInputRows);
}
public void GetAllCompanies_Should_Return_And_Empty_List_When_There_Is_No_Company()
{
// Given
_companyRepositoryMock.Setup(x => x.GetAllCompanies()).Returns(new List <Company>());
// When
var result = _companyService.GetAllCompanies();
// Then
Assert.IsEmpty(result);
}
public void ListaAutoresDeLivrosRetornarNaoOK()
{
var resultado = "";
foreach (var item in ListaDeAutores.ListaAutoresDeLivros())
{
resultado = item;
}
Assert.IsEmpty(resultado, "Retornar Não OK!");
}
public void IApiSecretValidation()
{
var result = ValidationHandler.ValidateIApiSecret(ApiSecretFaulted);
Assert.IsFalse(result.Item1);
Assert.IsNotEmpty(result.Item2);
var result2 = ValidationHandler.ValidateIApiSecret(ApiSecretCorrect);
Assert.IsTrue(result2.Item1);
Assert.IsEmpty(result2.Item2);
}
public void TestInputParser_IncrementValNotDouble_ReturnsNoProductIncrementValue()
{
IList <string> inputTexts = new[]
{
"Product,Origin Year,Development Year,Incremental Value",
"Comp,1990,1991,xyz"
};
var inputParser = new InputParser();
Assert.IsEmpty(inputParser.ParseInput(inputTexts));
Assert.That(inputParser.InvalidInputRows.Count() == 1);
Assert.That(inputParser.InvalidInputRows.Contains(inputTexts[1]));
}
public void TestInputParser_MissingColumn_ReturnsNoProductIncrementValue()
{
IList <string> inputTexts = new[]
{
"Product,Origin Year,Development Year,Incremental Value",
"1990,2020,310"
};
var inputParser = new InputParser();
Assert.IsEmpty(inputParser.ParseInput(inputTexts));
Assert.That(inputParser.InvalidInputRows.Count() == 1);
Assert.That(inputParser.InvalidInputRows.Contains(inputTexts[1]));
}
public IEnumerator ItRoutesMessagesByType()
{
CreateClient(ChannelParameterOne);
yield return(WaitForClientToSettle());
Assert.IsEmpty(client.receivedMessages);
yield return(OnFacet <BroadcastingFacet> .Call(
nameof(BroadcastingFacet.SendMyMessage),
ChannelParameterOne,
"Hello world!"
).AsCoroutine());
yield return(OnFacet <BroadcastingFacet> .Call(
nameof(BroadcastingFacet.SendMyOtherMessage),
ChannelParameterOne,
42
).AsCoroutine());
yield return(WaitForMessages(2));
Assert.AreEqual(2, client.receivedMessages.Count);
Assert.AreEqual(2, client.calledMethods.Count);
Assert.IsInstanceOf <MyMessage>(client.receivedMessages[0]);
Assert.AreEqual(
"Hello world!",
((MyMessage)client.receivedMessages[0]).foo
);
Assert.AreEqual(
nameof(MyBroadcastingClient.OnMyMessage),
client.calledMethods[0]
);
Assert.IsInstanceOf <MyOtherMessage>(client.receivedMessages[1]);
Assert.AreEqual(
42,
((MyOtherMessage)client.receivedMessages[1]).bar
);
Assert.AreEqual(
nameof(MyBroadcastingClient.OnMyOtherMessage),
client.calledMethods[1]
);
yield return(null);
}
public void TestInputParser_HeadingOrderDifferent_ReturnsOneProductIncrementValue2()
{
IList <string> inputTexts = new[]
{
"Incremental Value,Origin Year, Product, Development Year",
"310,1990, Comp, 1991"
};
var inputParser = new InputParser();
var parsedValues = inputParser.ParseInput(inputTexts);
Assert.That(parsedValues.Count() == 1);
Assert.That(parsedValues.FirstOrDefault().ProductName == "Comp");
Assert.That(parsedValues.FirstOrDefault().OriginYear == 1990);
Assert.That(parsedValues.FirstOrDefault().DevelopmentYear == 1991);
Assert.That(parsedValues.FirstOrDefault().IncrementalValue == 310);
Assert.IsEmpty(inputParser.InvalidInputRows);
}
public void TestInputParser_TwoRows_ReturnsOneProductIncrementValue()
{
IList <string> inputTexts = new[]
{
"Product,Origin Year,Development Year,Incremental Value",
"Comp,1990,1991,310"
};
var inputParser = new InputParser();
var parsedValues = inputParser.ParseInput(inputTexts);
Assert.That(parsedValues.Count() == 1);
Assert.That(parsedValues.FirstOrDefault().ProductName == "Comp");
Assert.That(parsedValues.FirstOrDefault().OriginYear == 1990);
Assert.That(parsedValues.FirstOrDefault().DevelopmentYear == 1991);
Assert.That(parsedValues.FirstOrDefault().IncrementalValue == 310);
Assert.IsEmpty(inputParser.InvalidInputRows);
}
public void TestParseMovieSearchParams()
{
var torznabCaps = new TorznabCapabilities();
torznabCaps.ParseMovieSearchParams(null);
Assert.IsEmpty(torznabCaps.MovieSearchParams);
torznabCaps = new TorznabCapabilities();
torznabCaps.ParseMovieSearchParams(new List <string>());
Assert.IsEmpty(torznabCaps.MovieSearchParams);
torznabCaps = new TorznabCapabilities();
torznabCaps.ParseMovieSearchParams(new List <string> {
"q", "imdbid"
});
Assert.AreEqual(new List <MovieSearchParam> {
MovieSearchParam.Q, MovieSearchParam.ImdbId
}, torznabCaps.MovieSearchParams);
torznabCaps = new TorznabCapabilities();
try {
torznabCaps.ParseMovieSearchParams(new List <string> {
"q", "q"
}); // duplicate param
Assert.Fail();
}
catch (Exception)
{
// ignored
}
torznabCaps = new TorznabCapabilities();
try {
torznabCaps.ParseMovieSearchParams(new List <string> {
"bad"
}); // unsupported param
Assert.Fail();
}
catch (Exception)
{
// ignored
}
}
[Category(TestCategory.Jira)] //TOOLS-7021
public void GetFeaturesInRangeShouldNotThrowForGeometryNull()
{
var features = GeometryHelper.GetFeaturesInRange(new Coordinate(0, 0),
new[]
{
new Feature {
Geometry = null
},
new Feature {
Geometry = null
},
new Feature {
Geometry = null
}
},
5).ToArray();
Assert.IsEmpty(features);
var feature1 = new Feature {
Geometry = new Point(0.2, 1)
};
var feature2 = new Feature {
Geometry = new Point(1, 0, 2)
};
features = GeometryHelper.GetFeaturesInRange(new Coordinate(0, 0),
new[]
{
feature1,
new Feature {
Geometry = null
},
feature2
},
5).ToArray();
Assert.AreEqual(2, features.Count());
Assert.Contains(feature1, features);
Assert.Contains(feature2, features);
}
public void TestInputParser_MultipleValidInput_ReturnsCorrectProductIncrementValues()
{
IList <string> inputTexts = new[]
{
"Product,Origin Year,Development Year,Incremental Value",
"Comp,1992,1992,110.0",
"Comp,1992,1993,170.0",
"Comp,1993,1993,200.0",
"Non-Comp, 1990, 1990, 45.2",
"Non-Comp, 1990, 1991, 64.8",
"Non-Comp, 1990, 1993, 37.0",
"Non-Comp, 1991, 1991, 50.0",
"Non-Comp, 1991, 1992, 75.0",
"Non-Comp, 1991, 1993, 25.0",
"Non-Comp, 1992, 1992, 55.0",
"Non-Comp, 1992, 1993, 85.0",
"Non-Comp, 1993, 1993, 100.0"
};
var inputParser = new InputParser();
var parsedValues = inputParser.ParseInput(inputTexts);
Assert.That(parsedValues.Count() == 12);
Assert.IsEmpty(inputParser.InvalidInputRows);
}
public IEnumerator ItDoesntReceiveMessagesAfterUnsubscribing()
{
CreateClient(ChannelParameterOne);
yield return(WaitForClientToSettle());
Assert.IsEmpty(client.receivedMessages);
yield return(OnFacet <BroadcastingFacet> .Call(
nameof(BroadcastingFacet.SendMyMessage),
ChannelParameterOne,
"Hello world!"
).AsCoroutine());
yield return(WaitForMessages(1));
// disable --> unsubscribes
client.gameObject.SetActive(false);
// clear log
client.receivedMessages.Clear();
// send a message
yield return(OnFacet <BroadcastingFacet> .Call(
nameof(BroadcastingFacet.SendMyMessage),
ChannelParameterOne,
"Hello world!"
).AsCoroutine());
// wait a sec.
yield return(new WaitForSeconds(1f));
// nothing
Assert.IsEmpty(client.receivedMessages);
yield return(null);
}
public IEnumerator ItCanSubscribeToAChannelAndReceiveAMessage()
{
CreateClient(ChannelParameterOne);
yield return(WaitForClientToSettle());
Assert.IsEmpty(client.receivedMessages);
yield return(OnFacet <BroadcastingFacet> .Call(
nameof(BroadcastingFacet.SendMyMessage),
ChannelParameterOne,
"Hello world!"
).AsCoroutine());
yield return(WaitForMessages(1));
Assert.AreEqual(1, client.receivedMessages.Count);
Assert.IsInstanceOf <MyMessage>(client.receivedMessages[0]);
Assert.AreEqual(
"Hello world!",
((MyMessage)client.receivedMessages[0]).foo
);
yield return(null);
}
public void posaljiPorukuBasicTest()
{
List <Korisnik> result = centrala.posaljiPoruku(poruka);
Assert.IsEmpty(result);
}
public void TestParseBookSearchParams()
{
var torznabCaps = new TorznabCapabilities();
torznabCaps.ParseCardigannSearchModes(new Dictionary <string, List <string> >
{
{ "search", new List <string> {
"q"
} },
{ "book-search", null }
});
Assert.IsEmpty(torznabCaps.MovieSearchParams);
torznabCaps = new TorznabCapabilities();
torznabCaps.ParseCardigannSearchModes(new Dictionary <string, List <string> >
{
{ "search", new List <string> {
"q"
} },
{ "book-search", new List <string>() }
});
Assert.IsEmpty(torznabCaps.MovieSearchParams);
torznabCaps = new TorznabCapabilities();
torznabCaps.ParseCardigannSearchModes(new Dictionary <string, List <string> >
{
{ "search", new List <string> {
"q"
} },
{ "book-search", new List <string> {
"q", "title"
} }
});
Assert.AreEqual(new List <BookSearchParam> {
BookSearchParam.Q, BookSearchParam.Title
}, torznabCaps.BookSearchParams);
torznabCaps = new TorznabCapabilities();
try {
torznabCaps.ParseCardigannSearchModes(new Dictionary <string, List <string> >
{
{ "search", new List <string> {
"q"
} },
{ "book-search", new List <string> {
"q", "q"
} } // duplicate param
});
Assert.Fail();
}
catch (Exception)
{
// ignored
}
torznabCaps = new TorznabCapabilities();
try {
torznabCaps.ParseCardigannSearchModes(new Dictionary <string, List <string> >
{
{ "search", new List <string> {
"q"
} },
{ "book-search", new List <string> {
"bad"
} } // unsupported param
});
Assert.Fail();
}
catch (Exception)
{
// ignored
}
}
public void ShuffleEmptyEnumerable()
{
var empty = Enumerable.Empty <object>();
Assert.IsEmpty(empty.Shuffle(), "Cannot shuffle empty list");
}
