public void ConstructorWithParameter(IEnumerable <double> collection, int expected)
{
Queue.Queue <double> queue = new Queue.Queue <double>(collection);
var result = queue.Count;
Assert.AreEqual(expected, result);
}
public List <Queue.Queue> GetPendingQueue()
{
var queued = new List <Queue.Queue>();
foreach (var pendingRelease in GetPendingReleases())
{
foreach (var episode in pendingRelease.RemoteEpisode.Episodes)
{
var ect = pendingRelease.Release.PublishDate.AddMinutes(GetDelay(pendingRelease.RemoteEpisode));
var queue = new Queue.Queue
{
Id = HashConverter.GetHashInt31(string.Format("pending-{0}-ep{1}", pendingRelease.Id, episode.Id)),
Series = pendingRelease.RemoteEpisode.Series,
Episode = episode,
Quality = pendingRelease.RemoteEpisode.ParsedEpisodeInfo.Quality,
Title = pendingRelease.Title,
Size = pendingRelease.RemoteEpisode.Release.Size,
Sizeleft = pendingRelease.RemoteEpisode.Release.Size,
RemoteEpisode = pendingRelease.RemoteEpisode,
Timeleft = ect.Subtract(DateTime.UtcNow),
EstimatedCompletionTime = ect,
Status = "Pending"
};
queued.Add(queue);
}
}
return(queued);
}
public List <Queue.Queue> GetPendingQueue()
{
var queued = new List <Queue.Queue>();
foreach (var pendingRelease in GetPendingReleases())
{
foreach (var episode in pendingRelease.RemoteEpisode.Episodes)
{
var ect = pendingRelease.Release.PublishDate.AddHours(
pendingRelease.RemoteEpisode.Series.Profile.Value.GrabDelay);
var queue = new Queue.Queue
{
Id = episode.Id ^ (pendingRelease.Id << 16),
Series = pendingRelease.RemoteEpisode.Series,
Episode = episode,
Quality = pendingRelease.RemoteEpisode.ParsedEpisodeInfo.Quality,
Title = pendingRelease.Title,
Size = pendingRelease.RemoteEpisode.Release.Size,
Sizeleft = pendingRelease.RemoteEpisode.Release.Size,
Timeleft = ect.Subtract(DateTime.UtcNow),
EstimatedCompletionTime = ect,
Status = "Pending",
RemoteEpisode = pendingRelease.RemoteEpisode
};
queued.Add(queue);
}
}
return(queued);
}
public void Peek(IEnumerable <string> collection, string expected)
{
Queue.Queue <string> queue = new Queue.Queue <string>(collection);
var result = queue.Dequeue();
Assert.AreEqual(expected, result);
}
public override bool Equals(Queue.Queue<int> q1, Queue.Queue<int> q2)
{
if (q1 == null || q2 == null)
return false;
return q1.ToStringForInts().Equals(q2.ToStringForInts());
}
public List <Queue.Queue> GetPendingQueue()
{
var queued = new List <Queue.Queue>();
foreach (var pendingRelease in GetPendingReleases())
{
foreach (var episode in pendingRelease.RemoteEpisode.Episodes)
{
var ect = pendingRelease.Release.PublishDate.AddMinutes(GetDelay(pendingRelease.RemoteEpisode));
var queue = new Queue.Queue
{
Id = GetQueueId(pendingRelease, episode),
Series = pendingRelease.RemoteEpisode.Series,
Episode = episode,
Quality = pendingRelease.RemoteEpisode.ParsedEpisodeInfo.Quality,
Title = pendingRelease.Title,
Size = pendingRelease.RemoteEpisode.Release.Size,
Sizeleft = pendingRelease.RemoteEpisode.Release.Size,
RemoteEpisode = pendingRelease.RemoteEpisode,
Timeleft = ect.Subtract(DateTime.UtcNow),
EstimatedCompletionTime = ect,
Status = "Pending",
Protocol = pendingRelease.RemoteEpisode.Release.DownloadProtocol
};
queued.Add(queue);
}
}
return(queued);
}
public IEnumerator <T> GetEnumerator()
{
Queue.Queue <TreeNode <T> > q = new Queue.Queue <TreeNode <T> >();
if (Count > 0)
{
q.Enqueue(Root);
}
while (q.Count != 0)
{
var node = q.Dequeue();
yield return(node.Data);
if (!IsEdgeSentinel(node.Left))
{
q.Enqueue(node.Left);
}
if (!IsEdgeSentinel(node.Right))
{
q.Enqueue(node.Right);
}
}
}
static void Main(string[] args)
{
Queue.Queue <int> queue = new Queue.Queue <int>(4);
queue.Push(1);
queue.Push(3);
queue.Push(4);
foreach (var element in queue)
{
Console.WriteLine(element);
}
Console.WriteLine();
//queue.Pop();
foreach (var element in queue)
{
Console.WriteLine(element);
}
Console.WriteLine();
Console.WriteLine(queue.Capacity);
Console.WriteLine(queue.Count);
Console.WriteLine(queue.Contains(2));
Console.WriteLine(queue.Contains(4));
Console.WriteLine(queue.Peek());
Console.ReadLine();
}
public List <Queue.Queue> GetPendingQueue()
{
var queued = new List <Queue.Queue>();
var nextRssSync = new Lazy <DateTime>(() => _taskManager.GetNextExecution(typeof(RssSyncCommand)));
foreach (var pendingRelease in GetPendingReleases().Where(p => p.Reason != PendingReleaseReason.Fallback))
{
foreach (var episode in pendingRelease.RemoteEpisode.Episodes)
{
var ect = pendingRelease.Release.PublishDate.AddMinutes(GetDelay(pendingRelease.RemoteEpisode));
if (ect < nextRssSync.Value)
{
ect = nextRssSync.Value;
}
else
{
ect = ect.AddMinutes(_configService.RssSyncInterval);
}
var timeleft = ect.Subtract(DateTime.UtcNow);
if (timeleft.TotalSeconds < 0)
{
timeleft = TimeSpan.Zero;
}
var queue = new Queue.Queue
{
Id = GetQueueId(pendingRelease, episode),
Series = pendingRelease.RemoteEpisode.Series,
Episode = episode,
Quality = pendingRelease.RemoteEpisode.ParsedEpisodeInfo.Quality,
Title = pendingRelease.Title,
Size = pendingRelease.RemoteEpisode.Release.Size,
Sizeleft = pendingRelease.RemoteEpisode.Release.Size,
RemoteEpisode = pendingRelease.RemoteEpisode,
Timeleft = timeleft,
EstimatedCompletionTime = ect,
Status = pendingRelease.Reason.ToString(),
Protocol = pendingRelease.RemoteEpisode.Release.DownloadProtocol
};
queued.Add(queue);
}
}
//Return best quality release for each episode
var deduped = queued.GroupBy(q => q.Episode.Id).Select(g =>
{
var series = g.First().Series;
return(g.OrderByDescending(e => e.Quality, new QualityModelComparer(series.Profile))
.ThenBy(q => PrioritizeDownloadProtocol(q.Series, q.Protocol))
.First());
});
return(deduped.ToList());
}
static void Main(string[] args)
{
Queue.Queue <int> a = new Queue.Queue <int>(5, 3, 8, 2);
a.Enqueue(1);
a.Enqueue(2);
a.Enqueue(3);
a.Enqueue(4);
a.Enqueue(5);
a.Enqueue(6);
a.Dequeue();
Console.WriteLine("Contains {0}\t Count {1}\nMoveNext {2}\t Current {3}",
a.Contains(2), a.Count(), a.MoveNext(3), a.Current);
a.Show();
a.DeqeueAt(a.Current);
a.Show();
Queue.Queue <int> b = new Queue.Queue <int>(5, 3, 8, 2);
b.Enqueue(1);
b.Enqueue(2);
b.Enqueue(3);
b.Enqueue(4);
b.Enqueue(5);
b.Enqueue(6);
Console.WriteLine(Equals(a, b));
Console.WriteLine(a.Equals(b));
Console.WriteLine(a.GetHashCode());
Console.WriteLine(b.GetHashCode());
Console.ReadKey();
}
public void Initialization()
{
_queue = new Queue.Queue <int>(3);
for (int i = 0; i < 7; i++)
{
_queue.Push(i);
}
}
public void TakeCollectionTest_ValidResult(int[] expected)
{
Queue.Queue <int> actual = new Queue.Queue <int>(expected);
for (int i = 0; i < expected.Length; i++)
{
Assert.AreEqual(expected[i], actual.Dequeue());
}
}
public int DequeueMethod_EnqueueElementFromQueue(int[] array, int count)
{
Queue.Queue <int> queue = new Queue.Queue <int>(array);
while (count-- > 1)
{
queue.Dequeue();
}
return(queue.Dequeue());
}
public void GetEnumeratorMethod_EnumerateElementsOfTheQueueIfChange(int[] array, int value)
{
Queue.Queue <int> queue = new Queue.Queue <int>(array);
IEnumerator <int> enumerator = queue.GetEnumerator();
enumerator.MoveNext();
queue.Enqueue(value);
int current = enumerator.Current;
enumerator.Dispose();
}
public void TwoCustomTypes_ContainInQueue()
{
Elements element1 = new Elements(1, "100");
Elements element2 = new Elements(12345, "12345");
Queue.Queue <Elements> elementQueue = new Queue.Queue <Elements>();
elementQueue.EnQueue(new Elements(1, "100"));
elementQueue.EnQueue(element2);
Assert.IsFalse(elementQueue.Contains(element1));
}
public string GetEnumeratorMethod_EnumerateElementsOfTheQueue(int[] array)
{
Queue.Queue <int> queue = new Queue.Queue <int>(array);
StringBuilder builder = new StringBuilder();
foreach (var element in queue)
{
builder.Append(element.ToString());
}
return(builder.ToString());
}
public override int GetHashCode(Queue.Queue<int> q)
{
int hash = 0;
int[] qArray = q.ToArray();
for (int i = 0; i < qArray.Length; i++)
{
hash += i * qArray[i];
}
return hash;
}
public void TwoCustomTypesIEquatable_ContainInQueue()
{
ElementsIEquatable element1 = new ElementsIEquatable(1, "100");
ElementsIEquatable element2 = new ElementsIEquatable(1, "100");
Queue.Queue <ElementsIEquatable> elementQueue = new Queue.Queue <ElementsIEquatable>();
elementQueue.EnQueue(new ElementsIEquatable(1, "100"));
elementQueue.EnQueue(element2);
Assert.IsFalse(elementQueue.Contains(element1));
}
public void GetEnumerator()
{
int[] sourceArray = { 1, 2, 3, 4, 5 };
Queue.Queue <int> queue = new Queue.Queue <int>(sourceArray);
List <int> result = new List <int>();
foreach (var item in queue)
{
result.Add(item);
}
CollectionAssert.AreEqual(sourceArray, result);
}
public List <Queue.Queue> GetPendingQueue()
{
var queued = new List <Queue.Queue>();
var nextRssSync = new Lazy <DateTime>(() => _taskManager.GetNextExecution(typeof(RssSyncCommand)));
foreach (var pendingRelease in GetPendingReleases())
{
var ect = pendingRelease.Release.PublishDate.AddMinutes(GetDelay(pendingRelease.RemoteMovie));
if (ect < nextRssSync.Value)
{
ect = nextRssSync.Value;
}
else
{
ect = ect.AddMinutes(_configService.RssSyncInterval);
}
var queue = new Queue.Queue
{
Id = GetQueueId(pendingRelease, pendingRelease.RemoteMovie.Movie),
Series = null,
Episode = null,
Movie = pendingRelease.RemoteMovie.Movie,
Quality = pendingRelease.RemoteMovie.ParsedMovieInfo?.Quality ?? new QualityModel(),
Title = pendingRelease.Title,
Size = pendingRelease.RemoteMovie.Release.Size,
Sizeleft = pendingRelease.RemoteMovie.Release.Size,
RemoteMovie = pendingRelease.RemoteMovie,
Timeleft = ect.Subtract(DateTime.UtcNow),
EstimatedCompletionTime = ect,
Status = "Pending",
Protocol = pendingRelease.RemoteMovie.Release.DownloadProtocol
};
queued.Add(queue);
}
//Return best quality release for each episode
var deduped = queued.GroupBy(q => q.Movie.Id).Select(g =>
{
var movies = g.First().Movie;
return(g.OrderByDescending(e => e.Quality, new QualityModelComparer(movies.Profile))
.ThenBy(q => PrioritizeDownloadProtocol(q.Movie, q.Protocol))
.First());
});
return(deduped.ToList());
}
public void Initialize()
{
var config = new ConfigurationBuilder()
.AddUserSecrets <QueueTest>()
.Build();
string connectionString = config["Queue:ConnectionString"];
manager = new QueueManager(connectionString);
queue = manager.CreateQueueAsync(queueName).Result;
Assert.IsNotNull(queue);
Assert.IsTrue(manager.ExistsQueueAsync(queueName).Result);
Assert.AreEqual(queue.Name, queueName);
}
public int EnqueueMethod_EnqueueElementFromToQueueAndGetLast(int[] array)
{
Queue.Queue <int> queue = new Queue.Queue <int>();
foreach (var element in array)
{
queue.Enqueue(element);
}
int count = array.Length;
while (count-- > 1)
{
queue.Dequeue();
}
return(queue.Dequeue());
}
public List <Queue.Queue> GetPendingQueue()
{
var queued = new List <Queue.Queue>();
var nextRssSync = new Lazy <DateTime>(() => _taskManager.GetNextExecution(typeof(RssSyncCommand)));
var pendingReleases = IncludeRemoteAlbums(_repository.WithoutFallback());
foreach (var pendingRelease in pendingReleases)
{
foreach (var album in pendingRelease.RemoteAlbum.Albums)
{
var ect = pendingRelease.Release.PublishDate.AddMinutes(GetDelay(pendingRelease.RemoteAlbum));
if (ect < nextRssSync.Value)
{
ect = nextRssSync.Value;
}
else
{
ect = ect.AddMinutes(_configService.RssSyncInterval);
}
var timeleft = ect.Subtract(DateTime.UtcNow);
if (timeleft.TotalSeconds < 0)
{
timeleft = TimeSpan.Zero;
}
var queue = new Queue.Queue
{
Id = GetQueueId(pendingRelease, album),
Artist = pendingRelease.RemoteAlbum.Artist,
Album = album,
Quality = pendingRelease.RemoteAlbum.ParsedAlbumInfo.Quality,
Title = pendingRelease.Title,
Size = pendingRelease.RemoteAlbum.Release.Size,
Sizeleft = pendingRelease.RemoteAlbum.Release.Size,
RemoteAlbum = pendingRelease.RemoteAlbum,
Timeleft = timeleft,
EstimatedCompletionTime = ect,
Status = pendingRelease.Reason.ToString(),
Protocol = pendingRelease.RemoteAlbum.Release.DownloadProtocol,
Indexer = pendingRelease.RemoteAlbum.Release.Indexer
};
queued.Add(queue);
}
}
//Return best quality release for each album
var deduped = queued.GroupBy(q => q.Album.Id).Select(g =>
{
var artist = g.First().Artist;
return(g.OrderByDescending(e => e.Quality, new QualityModelComparer(artist.QualityProfile))
.ThenBy(q => PrioritizeDownloadProtocol(q.Artist, q.Protocol))
.First());
});
return(deduped.ToList());
}
public void Test1()
{
Queue.Queue asdQueue = new Queue.Queue();
//asdQueue.
Assert.True(true);
}
public void Enqueue(IEnumerable <char> collection, char value, IEnumerable <char> expected)
{
Queue.Queue <char> queue = new Queue.Queue <char>(collection);
queue.Enqueue(value);
CollectionAssert.AreEqual(expected.ToArray(), queue.ToArray());
}
static void Main(string[] args)
{
// Queue tests
Queue.Queue <int> queue = new Queue.Queue <int>(5);
queue.Push(1);
queue.Push(2);
queue.Push(3);
queue.Push(4);
queue.Push(5);
queue.Push(6);
Console.WriteLine(queue.Count);
for (int i = 0; i < 4; i++)
{
Console.WriteLine(queue.Pop());
}
Console.WriteLine();
foreach (int item in queue)
{
Console.WriteLine(item);
}
Console.WriteLine(queue.Count);
Console.WriteLine(queue.Pop());
Console.WriteLine();
// Tree tests
BinarySearchTree <Book> tree = new BinarySearchTree <Book>(
new AuthorComparer(),
new Book[] {
new Book("ISBN", "Title", "C", "PublishingHous", 2005, 200, 50),
new Book("ISBN", "Title", "B", "PublishingHous", 2005, 200, 50),
new Book("ISBN", "Title", "A", "PublishingHous", 2005, 200, 50),
new Book("ISBN", "Title", "E", "PublishingHous", 2005, 200, 50),
new Book("ISBN", "Title", "D", "PublishingHous", 2005, 200, 50)
});
foreach (Book s in tree.DirectBypass().ToList())
{
Console.WriteLine(s);
}
// Matrix generator tests
Generator <int> g = new Generator <int>();
Matrix <int> intMatrix = g.GenearteDiagonalMatrix(5, new int[5] {
1, 2, 3, 4, 5
});
intMatrix.MatrixElementChangeEvent += MyConsoleEvent;
intMatrix[2, 4] = 15;
// Summ test
Matrix <int> first = new Matrix <int>(2);
first[0, 0] = 1;
first[0, 1] = 2;
first[1, 0] = 3;
first[1, 1] = 4;
Matrix <int> second = new Matrix <int>(2);
second[0, 0] = 4;
second[0, 1] = 3;
second[1, 0] = 2;
second[1, 1] = 1;
Matrix <int> result = first + second;
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 2; j++)
{
Console.Write(result[i, j] + " ");
}
Console.WriteLine();
}
Console.ReadLine();
}
public List <Queue.Queue> GetPendingQueue()
{
var queued = new List <Queue.Queue>();
var nextRssSync = new Lazy <DateTime>(() => _taskManager.GetNextExecution(typeof(RssSyncCommand)));
var pendingReleases = IncludeRemoteMovies(_repository.WithoutFallback());
foreach (var pendingRelease in pendingReleases)
{
if (pendingRelease.RemoteMovie != null)
{
pendingRelease.RemoteMovie.CustomFormats = _formatCalculator.ParseCustomFormat(pendingRelease.ParsedMovieInfo);
var ect = pendingRelease.Release.PublishDate.AddMinutes(GetDelay(pendingRelease.RemoteMovie));
if (ect < nextRssSync.Value)
{
ect = nextRssSync.Value;
}
else
{
ect = ect.AddMinutes(_configService.RssSyncInterval);
}
var timeleft = ect.Subtract(DateTime.UtcNow);
if (timeleft.TotalSeconds < 0)
{
timeleft = TimeSpan.Zero;
}
var queue = new Queue.Queue
{
Id = GetQueueId(pendingRelease, pendingRelease.RemoteMovie.Movie),
Movie = pendingRelease.RemoteMovie.Movie,
Quality = pendingRelease.RemoteMovie.ParsedMovieInfo?.Quality ?? new QualityModel(),
Languages = pendingRelease.RemoteMovie.ParsedMovieInfo?.Languages ?? new List <Language>(),
Title = pendingRelease.Title,
Size = pendingRelease.RemoteMovie.Release.Size,
Sizeleft = pendingRelease.RemoteMovie.Release.Size,
RemoteMovie = pendingRelease.RemoteMovie,
Timeleft = timeleft,
EstimatedCompletionTime = ect,
Status = pendingRelease.Reason.ToString(),
Protocol = pendingRelease.RemoteMovie.Release.DownloadProtocol,
Indexer = pendingRelease.RemoteMovie.Release.Indexer
};
queued.Add(queue);
}
}
//Return best quality release for each movie
var deduped = queued.GroupBy(q => q.Movie.Id).Select(g =>
{
var movies = g.First().Movie;
return(g.OrderByDescending(e => e.Quality, new QualityModelComparer(movies.Profile))
.ThenBy(q => PrioritizeDownloadProtocol(q.Movie, q.Protocol))
.First());
});
return(deduped.ToList());
}
public int PeekMethod_PeekElementFromHeadQueue(int[] array)
{
Queue.Queue <int> queue = new Queue.Queue <int>(array);
return(queue.Peek());
}
