static void Main(string[] args)
{
// work out a batch strategy
const int batchNumber = 100;
// get list of songs
string pathToItunesLibrary = ConfigSettings.PathToXml;
IEnumerable<Song> songs = new LibraryBuilder<Song>().BuildLibrary(pathToItunesLibrary);
int counter = 0;
int numberOfSongs = songs.Count();
int numberOfBatches = numberOfSongs/batchNumber;
// for each batch
for(int i=0; i< numberOfBatches; i++)
{
int start = counter;
// get list of songs
IEnumerable<Song> songBatch = songs.Skip(start).Take(batchNumber);
// add batch to Solr
Console.WriteLine("Adding {0} through to{1}", start, start + batchNumber);
counter += batchNumber;
}
Console.Read();
}
public void SetUp()
{
observer = MockRepository.GenerateMock <IFixtureObserver>();
builder = new LibraryBuilder(observer, new CompositeFilter <Type>());
builder.FixtureCount = 23;
}
public async Task IsTrueForUpdatedLibrary()
{
var song = new LocalSong("C://Song.mp3", TimeSpan.Zero);
var songFinder = Substitute.For <ILocalSongFinder>();
songFinder.GetSongsAsync().Returns(Observable.Return(Tuple.Create(song, (byte[])null)));
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData> {
{ "C://Song.mp3", new MockFileData("Bla") }
});
using (Library library = new LibraryBuilder().WithFileSystem(fileSystem).WithSongFinder(songFinder).Build())
{
Guid accessToken = library.LocalAccessControl.RegisterLocalAccessToken();
// NB: System.IO.Abstractions only likes backslashes
library.ChangeSongSourcePath("C:\\", accessToken);
var vm = new LocalViewModel(library, new ViewSettings(), new CoreSettings(), accessToken);
await library.AwaitInitializationAndUpdate();
Assert.False(vm.ShowAddSongsHelperMessage);
}
}
/// <summary>
/// Loads a dynamic wrapper of a specified library assembly.
/// </summary>
/// <returns>The dynamic wrapper assembly.</returns>
/// <remarks>Thread safe.</remarks>
public void LoadDynamicWrapper()
{
if (dynamicWrapper != null)
{
return;
}
Assembly real_assembly = PhpLibraryAssembly.RealAssembly;
if (PhpLibraryAssembly.Properties.ContainsDynamicStubs)
{
dynamicWrapper = real_assembly;
return;
}
#if SILVERLIGHT
this.dynamicWrapper = LibraryBuilder.CreateDynamicWrapper(real_assembly);
#else
if (!Configuration.IsLoaded && !Configuration.IsBeingLoaded)
{
return;
} // continue without wrappers !! (VS Integration does not need it)
string wrappers_dir = Configuration.GetPathsNoLoad().DynamicWrappers;
// determine wrapper file name,
// we are looking for an up-to-date wrapper or a writable location:
string wrapper_file = DetermineDynamicWrapperFileName(wrappers_dir, real_assembly);
string wrapper_fullfile = Path.Combine(wrappers_dir, wrapper_file);
//
try
{
// builds wrapper if it doesn't exist:
if (!IsDynamicWrapperUpToDate(real_assembly, wrapper_fullfile))
{
Mutex mutex = new Mutex(false, String.Concat(@"Global\", wrapper_fullfile.ToLowerInvariant().Replace('\\', '/').Replace(':', '+'))); // do not use \ and : characters, to not confuse Mutex with file system which may not be accessible in this moment
mutex.WaitOne();
try
{
// if the file still does not exist, we are in charge!
if (!IsDynamicWrapperUpToDate(real_assembly, wrapper_fullfile))
{
LibraryBuilder.CreateDynamicWrapper(real_assembly, wrappers_dir, wrapper_file);
}
}
finally
{
mutex.ReleaseMutex();
}
}
// loads wrapper:
this.dynamicWrapper = System.Reflection.Assembly.LoadFrom(wrapper_fullfile);
}
catch (Exception e)
{
throw new DynamicWrapperLoadException(wrapper_fullfile, e);
}
#endif
}
static unsafe void Main(string[] args)
{
Span <byte> s;
//var x = File.OpenWrite("b.dll");
//AheadOfTimeActivator.WriteImplementation<TestClass>(x);
//var y = File.OpenWrite("a.dll");
//AheadOfTimeActivator.WriteImplementation<TestClass2>(y);
//x.Flush();
//y.Flush();
//var user32 = LibraryActivator.CreateInstance<TestClass>("user32.dll");
//user32.MessageBox(IntPtr.Zero, "SuperInvoke".ToCharArray(), "Hello from SuperInvoke!".ToCharArray(), 0);
if (AotTest)
{
var libBuilder = new LibraryBuilder();
var opts = BuilderOptions.GetDefault(typeof(TestClass2));
libBuilder.Add(opts);
#if NET47
var bytes = libBuilder.BuildBytes();
File.WriteAllBytes("c.dll", bytes);
#else
libBuilder.Build();
#endif
}
var lib = LibraryActivator.CreateInstance <TestClass2>("user32");
var a = Marshal.StringToHGlobalAnsi("Test 1");
var b = Marshal.StringToHGlobalAnsi("Hello from SuperInvoke!");
lib.MessageBox(default, (char *)a, (char *)b, 0);
public async Task Setup()
{
LibraryBuilder.AssignToUser(AccountId, Role.Writer).StartingWith(_startWith).Build(4);
_response = await Client.GetAsync($"/libraries?query={_startWith}");
_assert = new PagingAssert <LibraryView>(_response);
}
public async Task Setup()
{
LibraryBuilder.AssignToUser(AccountId, Role.Writer).Build(15);
_response = await Client.GetAsync($"/libraries?pageNumber=3&pageSize=5");
_assert = new PagingAssert <LibraryView>(_response);
}
public async Task Setup()
{
LibraryBuilder.AssignToUser(AccountId).Build(4);
_response = await Client.GetAsync($"/libraries");
_assert = new PagingAssert <LibraryView>(_response);
}
public void Can_build_valid_library_from_xml()
{
var xElements = new List<XElement> { new XElement("plist", new XElement("dlist", new XElement("artist", "billy idol"))) };
var lb = new LibraryBuilder<XElement>();
IEnumerable<XElement> buildLibrary = lb.BuildLibrary(xElements);
Assert.That(buildLibrary, Is.Not.Null);
Assert.That(buildLibrary.Count(), Is.GreaterThanOrEqualTo(1));
}
public async Task Setup()
{
_library = LibraryBuilder.Build();
_account = AccountBuilder.InLibrary(_library.Id).AsInvitation().Build();
_response = await Client.PostObject($"/accounts/invitations", new ResendInvitationCodeRequest()
{
Email = _account.Email
});
}
internal static NativeApiContainer UseStrategyOne(UnmanagedLibrary unmanagedLibrary, Type type, Strategy strat)
{
var ctx = new NativeApiContext(unmanagedLibrary, strat);
return((NativeApiContainer)Activator.CreateInstance(
(GetImplementationInDomain(type, AppDomain.CurrentDomain) ?? LibraryBuilder
.CreateAssembly(BuilderOptions.GetDefault(type))
.GetTypes().FirstOrDefault(type.IsAssignableFrom)) ??
throw new InvalidOperationException("Failed to create type."), ctx));
}
public void Should_return_1_song_based_on_name()
{
var librarybuilder = new LibraryBuilder<Song>();
var selector = new SongSelector(librarybuilder);
Song song = selector.FindSingle(x => x.Name == "Come Ray And Come Charles");
Assert.IsNotNull(song);
Assert.AreEqual("Come Ray And Come Charles", song.Name);
}
public static byte[] BuildBytes(this LibraryBuilder builder)
{
var asm = ((AssemblyBuilder)builder.Build());
asm.Save(builder.Name + ".dll");
var bytes = File.ReadAllBytes(builder.Name + ".dll");
File.Delete(builder.Name + ".dll");
return(bytes);
}
public void SetUp()
{
var context = new TestContext(x => { x.AddFixture <FixtureWithHiddenGrammarsFixture>(); });
var observer = MockRepository.GenerateMock <IFixtureObserver>();
var builder = new LibraryBuilder(observer, new CompositeFilter <Type>());
builder.Build(context);
library = builder.Library;
}
public async Task Setup()
{
var library = LibraryBuilder.WithOutAccount().Build();
_response = await Client.PostObject($"/accounts/invite/library/{library.Id}",
new InviteUserRequest
{
Email = RandomData.Email,
Role = Role.Reader
});
}
/// <summary>
/// The entry point.
/// </summary>
static void Main(string[] args)
{
Environment.ExitCode = 1;
Logo();
if (!ProcessArguments(args))
{
return;
}
Type attr = null;
if (resolve)
{
try
{
Assembly coreAsm = Assembly.LoadFrom("PhpNetCore.dll");
attr = coreAsm.GetType("PHP.Core.ImplementsFunctionAttribute");
}
catch (Exception e)
{
Console.WriteLine("Dynamic resolution of the 'ImplementsFunctionAttribute' failed: ", e.Message);
return;
}
}
Assembly assembly;
try
{
assembly = Assembly.LoadFrom(assemblyName);
}
catch (Exception e)
{
Console.WriteLine("Error occured while loading assembly: {0}", e.Message);
return;
}
string dynamic_assembly_path;
try
{
dynamic_assembly_path = LibraryBuilder.CreateDynamicWrapper(attr, assembly, directory, PHP.Core.Reflection.PhpLibraryModule.DynamicWrapperFileName(assembly, 0));
}
catch (Exception e)
{
Console.WriteLine("Error occured while generating wrapper: {0}", e.Message);
return;
}
Console.WriteLine("The dynamic wrapper '{0}' has been generated.", Path.GetFullPath(dynamic_assembly_path));
Environment.ExitCode = 0;
}
public TestBase(Role?role = null, bool periodicalsEnabled = false, bool createLibrary = true)
{
_periodicalsEnabled = periodicalsEnabled;
_role = role;
var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
var projectDir = Directory.GetCurrentDirectory();
var configPath = Path.Combine(projectDir, "appsettings.json");
_factory = new WebApplicationFactory <Startup>()
.WithWebHostBuilder(builder =>
{
builder.ConfigureAppConfiguration((context, conf) =>
{
conf.AddJsonFile(configPath);
if (!string.IsNullOrWhiteSpace(environment))
{
conf.AddJsonFile(Path.Combine(projectDir, $"appsettings.json"), true);
//conf.AddJsonFile(Path.Combine(projectDir, $"appsettings.{environment}.json"), true);
}
});
builder.ConfigureTestServices(services => ConfigureServices(services));
});
var settings = Services.GetService <Settings>();
AccountBuilder = _factory.Services.GetService <AccountDataBuilder>();
if (role.HasValue)
{
AccountBuilder = AccountBuilder.As(_role.Value).Verified();
_account = AccountBuilder.Build();
}
if (createLibrary)
{
var builder = LibraryBuilder.WithPeriodicalsEnabled(_periodicalsEnabled);
if (_account != null && role.HasValue)
{
builder.AssignToUser(AccountId, _role.Value);
}
Library = builder.Build();
}
Client = _factory.CreateClient();
if (_account != null)
{
var token = TokenBuilder.GenerateToken(settings, _account.Id);
Client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
}
}
public void SetUp()
{
observer = MockRepository.GenerateMock <IFixtureObserver>();
var filter = new CompositeFilter <Type>();
filter.Includes += t => t.Name.StartsWith("M");
builder = new LibraryBuilder(observer, filter);
library = builder.Build(new TestContext(x => x.AddFixturesFromThisAssembly()));
}
public void Should_return_songs_based_on_bitrate()
{
var librarybuilder = new LibraryBuilder<Song>();
var selector = new SongSelector(librarybuilder);
IEnumerable<Song> songs = selector.FindMany(x => x.BitRate > 40000);
IEnumerable<Song> allSongs = librarybuilder.BuildLibrary(ConfigSettings.PathToXml);
Assert.Greater(1, songs.Count());
Assert.Less(songs.Count(), allSongs.Count());
}
public void Can_build_valid_library_from_xml_file()
{
var xElements = new List<XElement>{new XElement("plist", new XElement("dlist", new XElement("artist", "billy idol")))};
var libraryParser = MockRepository.GenerateStub<ILibraryParser>();
libraryParser.Stub(x => x.ParseXml(Arg<string>.Is.Anything)).Return(xElements);
var lb = new LibraryBuilder<XElement>(libraryParser);
IEnumerable<XElement> buildLibrary = lb.BuildLibrary("");
Assert.That(buildLibrary, Is.Not.Null);
Assert.That(buildLibrary.Count(), Is.GreaterThanOrEqualTo(1));
}
public async Task Setup()
{
_library = LibraryBuilder.Build();
_response = await Client.PostObject($"/accounts/invite",
new InviteUserRequest
{
Name = _name,
Email = _email,
Role = Role.Admin
});
}
static async Task Main(string[] args)
{
try
{
var builder = new LibraryBuilder();
await builder.Build("/usr/share/dict/words", "/Users/mark/words.index2");
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public static void Main(string[] args)
{
var builder = new LibraryBuilder();
builder.Add(BuilderOptions.GetDefault(typeof(GL)));
File.WriteAllBytes("il.dll", builder.BuildBytes());
Process.Start
(
@"C:\Program Files (x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.7.2 Tools\ildasm.exe",
"/out=\"il.il\" \"il.dll\""
)?.WaitForExit();
}
public void SetUp()
{
var builder = new LibraryBuilder(new NulloFixtureObserver(), new CompositeFilter <Type>());
var registry = new FixtureRegistry();
registry.AddFixturesFromAssemblyContaining <SetUserAction>();
var container = registry.BuildContainer();
var context = new TestContext(container);
library = builder.Build(context);
}
public async Task Setup()
{
_library = LibraryBuilder.Build();
_account = AccountBuilder.InLibrary(_library.Id).AsInvitation().Build();
_response = await Client.PostObject($"/accounts/register/{_account.InvitationCode}",
new RegisterRequest
{
Name = _name,
Password = _password,
AcceptTerms = true
});
}
public async Task Setup()
{
var library = LibraryBuilder.Build();
var account = AccountBuilder.As(Domain.Models.Role.Admin).Verified().InLibrary(library.Id).Build();
_authResponse = await AccountBuilder.Authenticate(Client, account.Email);
AuthenticateClientWithToken(_authResponse.JwtToken);
_response = await Client.PostObject("/accounts/refresh-token", new RefreshTokenRequest { RefreshToken = _authResponse.RefreshToken });
_refreshResponse = await _response.GetContent <AuthenticateResponse>();
}
public void Should_batch_add_records_to_solr()
{
log4net.Config.XmlConfigurator.Configure();
// work out a batch strategy
const int batchNumber = 1000;
// get list of songs
string pathToItunesLibrary = ConfigSettings.PathToXml;
IEnumerable<Song> songs = new LibraryBuilder<Song>().BuildLibrary(pathToItunesLibrary);
songs = songs.Where(x => !string.IsNullOrEmpty(x.Artist) && !string.IsNullOrEmpty(x.Album));
var indexer = new BatchedIndexer<Song>(new SolrCastleResolver<Song>()) {BatchBy = batchNumber};
indexer.GenerateIndex(songs);
}
public async Task Setup()
{
var library = LibraryBuilder.Build();
var account = AccountBuilder.As(Role.Reader)
.InLibrary(library.Id)
.Verified()
.Build();
_response = await Client.PostObject($"/accounts/invite/library/{library.Id}",
new InviteUserRequest
{
Email = account.Email,
Role = Role.Reader
});
}
public void Should_return_list_of_type_song()
{
string pathToItunesLibrary = ConfigSettings.PathToXml;
IEnumerable<Song> songs = new LibraryBuilder<Song>().BuildLibrary(pathToItunesLibrary);
Assert.IsNotNull(songs);
int count = songs.Count();
Assert.Greater(count, 0);
var song = songs.First();
Assert.IsNotNull(song);
Assert.IsInstanceOfType(typeof(Song), song);
}
public void UsesPrecompiledTypesIfDiscovered()
{
// Pregenerate the types
Builder.WithSourceAssembly(GetType().Assembly);
var result = Builder.Build(OutputDirectory);
var searchPattern = $"*{result}*.dll";
NativeLibraryBuilder.DiscoverCompiledTypes(OutputDirectory, searchPattern);
var library = LibraryBuilder.ActivateInterface <IAOTLibrary>("AOTTests");
var libraryAssembly = library.GetType().Assembly;
Assert.False(libraryAssembly.GetCustomAttribute <AOTAssemblyAttribute>() is null);
}
private void fixturesShouldBe(params string[] names)
{
var builder = new LibraryBuilder(new NulloFixtureObserver(), project.CurrentFixtureFilter().CreateTypeFilter());
var library = builder.Build(new TestContext(x =>
{
x.AddFixture <OhioFixture>();
x.AddFixture <WisconsinFixture>();
x.AddFixture <IllinoisFixture>();
x.AddFixture <NorthFixture>();
x.AddFixture <SouthFixture>();
}));
Array.Sort(names);
library.ActiveFixtures.Select(x => x.Name).ShouldHaveTheSameElementsAs(names);
}
public void UniqueNameDoesValidate()
{
using (Library library = new LibraryBuilder().Build())
{
Guid accessToken = library.LocalAccessControl.RegisterLocalAccessToken();
library.AddPlaylist("Existing", accessToken);
library.AddPlaylist("New", accessToken);
var fixture = new PlaylistViewModel(library.Playlists.Single(x => x.Name == "New"), library, accessToken, new CoreSettings());
fixture.EditName = true;
fixture.Name = "Unique";
Assert.Null(fixture["Name"]);
}
}
public async Task Setup()
{
var name = RandomData.String;
var password = RandomData.String;
_library = LibraryBuilder.Build();
_account = AccountBuilder.InLibrary(_library.Id).AsInvitation().Build();
_response = await Client.PostObject($"/accounts/register/{Guid.NewGuid().ToString("N")}",
new RegisterRequest
{
Name = name,
Password = password,
AcceptTerms = true
});
}
public void CanExecuteWhenAdmin()
{
Song song = Helpers.SetupSongMock();
using (Library library = new LibraryBuilder().WithPlaylist("ThePlaylist").Build())
{
Guid accessToken = library.LocalAccessControl.RegisterLocalAccessToken();
var vm = new SongSourceViewModelMock(library, accessToken);
var songVm = Substitute.For <ISongViewModelBase>();
songVm.Model.Returns(song);
vm.SelectedSongs = new[] { songVm };
Assert.True(vm.AddToPlaylistCommand.CanExecute(null));
}
}
public async Task Setup()
{
_library1 = LibraryBuilder.Build();
_account = AccountBuilder.As(Role.Reader)
.InLibrary(_library1.Id)
.Verified()
.Build();
_library2 = LibraryBuilder.Build();
_response = await Client.PostObject($"/accounts/invite/library/{_library2.Id}",
new InviteUserRequest
{
Email = _account.Email,
Role = Role.LibraryAdmin
});
}
public async Task Setup()
{
var name = RandomData.String;
var password = RandomData.String;
_library = LibraryBuilder.Build();
_account = AccountBuilder.InLibrary(_library.Id)
.AsInvitation().ExpiringInvitation(DateTime.UtcNow.AddDays(-1)).Build();
_response = await Client.PostObject($"/accounts/register/{_account.InvitationCode}",
new RegisterRequest
{
Name = name,
Password = password,
AcceptTerms = true
});
}
public void UsesPrecompiledTypesIfDiscoveredFromStream()
{
// Pregenerate the types
Builder.WithSourceAssembly(GetType().Assembly);
var result = Builder.Build(OutputDirectory);
foreach (var asm in Directory.GetFiles(OutputDirectory, $"*{result}*.dll"))
{
NativeLibraryBuilder.DiscoverCompiledTypes(File.OpenRead(asm));
}
var library = LibraryBuilder.ActivateInterface <IAOTLibrary>("AOTTests");
var libraryAssembly = library.GetType().Assembly;
Assert.False(libraryAssembly.GetCustomAttribute <AOTAssemblyAttribute>() is null);
}
