public async Task ReturnsSource_ForNormalType()
{
var source1 = @"using System;
class Foo {
}";
var source2 = @"class Bar {
private Foo foo;
}";
var workspace = await TestHelpers.CreateSimpleWorkspace(new Dictionary<string, string> {
{ "foo.cs", source1 }, { "bar.cs", source2}
});
var controller = new MetadataService(workspace);
var response = await controller.Handle(new MetadataRequest
{
#if DNXCORE50
AssemblyName = "System.Linq",
#else
AssemblyName = "System.Core",
#endif
TypeName = "System.Linq.Enumerable",
Timeout = 60000
});
Assert.NotNull(response.Source);
}
public async Task ReturnsSource_ForGenericType()
{
var source1 = @"using System;
class Foo {
}";
var source2 = @"class Bar {
private Foo foo;
}";
var workspace = await TestHelpers.CreateSimpleWorkspace(new Dictionary<string, string> {
{ "foo.cs", source1 }, { "bar.cs", source2}
});
var controller = new MetadataService(workspace);
var response = await controller.Handle(new MetadataRequest
{
AssemblyName = "mscorlib",
TypeName = "System.Collections.Generic.List`1",
Timeout = 60000
});
Assert.NotNull(response.Source);
response = await controller.Handle(new MetadataRequest
{
AssemblyName = "mscorlib",
TypeName = "System.Collections.Generic.Dictionary`2"
});
Assert.NotNull(response.Source);
}
private void StartScreenshot(MetadataServiceConfigurator serviceConfigurator, string[] filePathes)
{
int count = 0;
double avgEncodeFps = 0;
var errorVideos = new List <string>();
var allSw = new Stopwatch();
var decodeSw = new Stopwatch();
foreach (string filePath in filePathes)
{
allSw.Restart();
Trace.WriteLine(String.Format("\n-------------Start decode file: {0}-------------\n", filePath));
try
{
string destinationFileName = GetDestinationFileName(filePath);
var mediaInfo = new MediaInfoWrapper();
var metadataInfo = new VideoMetadataInfo(mediaInfo);
VideoMediaInfo metadata = metadataInfo.GetMetadata(filePath);
var metadataService = new MetadataService(serviceConfigurator, metadata);
var stringBuilder = new FfmpegService(metadataService, filePath, _destinationPath, destinationFileName);
var ffmpeg = new Ffmpeg(stringBuilder);
string ffmpegString = stringBuilder.GetStringForScreenshot();
WriteFileInfo(ffmpegString, metadata);
decodeSw.Restart();
ffmpeg.StartScreenshotProcess();
allSw.Stop();
decodeSw.Stop();
WriteFinishProcess(decodeSw.Elapsed, allSw.Elapsed, ffmpeg.EncodeFps);
avgEncodeFps += ffmpeg.EncodeFps;
count++;
}
catch (MediaFormatException ex)
{
string errorMessage = String.Format("Error File:\t\t{0}.\nError Param:\t\t{1}", filePath, ex.Message);
Trace.WriteLine(errorMessage);
errorVideos.Add(errorMessage);
}
catch (ExternalProcessException ex)
{
string errorMessage = String.Format("Error File:\t\t{0}.\nFfmpeg return:\t\t{1}\n{2}", filePath, ex.Result, ex.Arguments);
Trace.WriteLine(errorMessage);
errorVideos.Add(errorMessage);
}
finally
{
Trace.WriteLine(String.Format("\n-------------Finish decode file: {0}-------------\n", filePath));
}
}
avgEncodeFps = avgEncodeFps / count;
WriteFinishInfo(avgEncodeFps, count, errorVideos);
}
public void AdjustAudioProfileTest()
{
//Arrange
const string myCodec1 = "myCodec1";
const string myCodec2 = "myCodec2";
const string anotherProfile = "anotherProfile";
const string firstProfile = "firstProfile";
var audioCodec = new CodecData(myCodec1, null, firstProfile);
var supportedAudioCodecs = new List <CodecData>()
{
audioCodec,
new CodecData(myCodec2, null)
};
var serviceConfigurator = new MetadataServiceConfigurator(null, null, null, audioCodec, supportedAudioCodecs);
var metadata1 = new VideoMetadata()
{
AudioCodec = myCodec1,
AudioProfile = firstProfile
};
var metadata2 = new VideoMetadata()
{
AudioCodec = myCodec1,
AudioProfile = anotherProfile
};
var metadata3 = new VideoMetadata()
{
AudioCodec = myCodec2,
AudioProfile = anotherProfile
};
var metadataWithoutProfile = new VideoMetadata()
{
AudioCodec = myCodec1,
AudioProfile = null
};
var metadataService1 = new MetadataService(serviceConfigurator, metadata1);
var metadataService2 = new MetadataService(serviceConfigurator, metadata2);
var metadataService3 = new MetadataService(serviceConfigurator, metadata3);
var metadataService4 = new MetadataService(serviceConfigurator, metadataWithoutProfile);
//Act
var profile1 = metadataService1.AdjustAudioProfile();
var profile2 = metadataService2.AdjustAudioProfile();
var profile3 = metadataService3.AdjustAudioProfile();
var profile4 = metadataService4.AdjustAudioProfile();
//Assert
Assert.AreEqual(firstProfile, profile1);
Assert.AreEqual(firstProfile, profile2);
Assert.AreEqual(anotherProfile, profile3);
Assert.AreEqual(firstProfile, profile4);
}
public static MetadataService CreateService()
{
var databaseConnection = new DatabaseConnection();
databaseConnection.ConnectionString = Properties.Settings.Default.TestDatabaseConnectionString;
var service = new MetadataService(databaseConnection);
return(service);
}
public ItemController(CategoryService categoryService, MetadataService metadataService,
ItemService itemService, UnitOfWork unitOfWork, DocumentService documentService, CurrentUser currentUser)
{
this._CategoryService = categoryService;
this._MetadataService = metadataService;
this._ItemService = itemService;
this._DocumentService = documentService;
_unitOfWork = unitOfWork;
_currentUser = currentUser;
}
public JsonResult UpdateExisitingEntities(int id)
{
CFMetadataSet metadata = MetadataService.GetMetadataSet(id);
int total = EntityService.UpdateExistingEntityMetadata(metadata);
Db.SaveChanges(User.Identity);
return(Json(total));
}
public async Task CanListAllEntities()
{
var connector = new ServiceConnector(new DemoConnection());
var service = new MetadataService(connector);
var metadata = await service.ListAllAsync();
Assert.IsNotNull(metadata);
}
public GeodatalovDatasetsController(RegisterDbContext dbContext, IGeodatalovDatasetService geodatalovDatasetService, IAccessControlService accessControllService, IRegisterService registerService, IRegisterItemService registerItemService, IDatasetDeliveryService datasetDeliveryService)
{
_db = dbContext;
_geodatalovDatasetService = geodatalovDatasetService;
_accessControlService = accessControllService;
_metadataService = new MetadataService(_db);
_registerService = registerService;
_registerItemService = registerItemService;
_datasetDeliveryService = datasetDeliveryService;
}
public MetadataApi(string sessionId, string metadataServerUrl)
{
_mtDataService = new MetadataService
{
SessionHeaderValue = new SessionHeader {
sessionId = sessionId
},
Url = metadataServerUrl
};
}
public override object GetContent(object model)
{
CatfishDbContext db = new CatfishDbContext();
MetadataService metadataSrv = new MetadataService(db);
if (!String.IsNullOrEmpty(Category))
{
var metadataSet = metadataSrv.GetMetadataSet(SelectedMetadataSetCat);
}
return(base.GetContent(model));
}
private static void SendTypes()
{
Console.WriteLine($"Sending types from file: {SdsTypePath}");
string types = File.ReadAllText(SdsTypePath);
List <SdsType> typeList = JsonConvert.DeserializeObject <List <SdsType> >(types);
foreach (var type in typeList)
{
MetadataService.GetOrCreateTypeAsync(type).Wait();
}
}
private MetadataService SetupMetadataService()
{
var metadataInfraService = new Infrastructure.Services.MetadataServiceMock();
var mapperConfig = new MapperConfiguration(mc =>
{
mc.AddProfile(new Mappings.AutoMapperMetadataProfile());
});
var metadataService = new MetadataService(metadataInfraService, mapperConfig.CreateMapper());
return(metadataService);
}
public ActionResult EditContentItem(long?contentItemId = null, int?contentTypeId = null)
{
pageResourceManager.InsertTitlePart("编辑资讯");
var metadataService = new MetadataService();
ContentTypeDefinition contentType = null;
ContentItem item = null;
if (contentItemId.HasValue && contentItemId.Value > 0)
{
item = contentItemService.Get(contentItemId.Value);
if (item == null)
{
return(HttpNotFound());
}
contentType = item.ContentType;
}
else
{
if (contentTypeId.HasValue && contentTypeId.Value > 0)
{
contentType = metadataService.GetContentType(contentTypeId.Value);
}
else
{
contentType = metadataService.GetContentTypes(true).FirstOrDefault();
}
if (contentType == null)
{
return(HttpNotFound());
}
}
ContentItemEditModel model = TempData.Get <ContentItemEditModel>("ContentItemEditModel", null);
if (model == null)
{
if (item != null)
{
model = item.AsEditModel();
}
else
{
model = new ContentItemEditModel {
ContentTypeId = contentType.ContentTypeId, ReleaseDate = DateTime.Now
};
}
}
else
{
TempData.Remove("ContentItemEditModel");
}
ViewData["contentItem"] = item;
return(View(contentItemId.HasValue ? contentType.Page_Edit : contentType.Page_New, model));
}
public async Task CanListEntityFields()
{
var connector = new ServiceConnector(new DemoConnection());
var entityLogicalName = "new_car";
var service = new MetadataService(connector);
var entityDefinition = await service.GetEntityDefinition(entityLogicalName);
Assert.IsNotNull(entityDefinition);
}
public override View OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
{
_fullAudioPath = AnalysisContext.FullAudioPath;
_metadataService = new MetadataService();
_audioFileService = new AudioFileService();
View view = inflater.Inflate(Resource.Layout.RecordingInfoFragment, container, false);
view.FindViewById <TextView>(Resource.Id.content).Text = GetContent();
return(view);
}
/// <summary>
/// Transforms a list of objects into a data table
/// </summary>
/// <typeparam name="T">Type of the objects</typeparam>
/// <param name="objects">List of objects</param>
/// <param name="derivedObjectType">Derived type of the objects if there's polymorphism</param>
/// <returns>A data table</returns>
public static DataTable AsStronglyTypedDataTable <T>(this IEnumerable <T> objects, Type derivedObjectType) where T : class
{
if (objects == null)
{
throw new ArgumentNullException(nameof(objects), $"{nameof(objects)} {CommonResources.App_CannotBeNull}");
}
if (derivedObjectType == null)
{
throw new ArgumentNullException(nameof(derivedObjectType), $"{nameof(derivedObjectType)} {CommonResources.App_CannotBeNull}");
}
using (IMetadataService metadataService = new MetadataService())
{
var tableName = metadataService.GetTableName(derivedObjectType);
var mappings = metadataService.GetMappings(derivedObjectType);
if (string.IsNullOrWhiteSpace(tableName))
{
throw new ArgumentNullException(nameof(tableName), $"{nameof(tableName)} {CommonResources.App_CannotBeNull}");
}
if (mappings == null)
{
throw new ArgumentNullException(nameof(mappings), $"{nameof(mappings)} {CommonResources.App_CannotBeNull}");
}
var dataTable = metadataService.GetTableSchema(tableName);
if (dataTable == null)
{
throw new ArgumentNullException(nameof(dataTable), $"{nameof(dataTable)} {CommonResources.App_CannotBeNull}");
}
if (dataTable.Columns == null)
{
throw new ArgumentNullException(nameof(dataTable.Columns), $"{nameof(dataTable.Columns)} {CommonResources.App_CannotBeNull}");
}
var dataColumn = new IgnoredDataColumn
{
ColumnName = "end_line",
DataType = typeof(string)
};
dataTable.Columns.Add(dataColumn);
dataTable = FillDataTable(objects, dataTable, mappings);
return(dataTable);
}
}
public void GetMp4StringFromIncorrectMetadataTest()
{
//Arrange
const string sourceFilePath = "source file path";
const string destinationPath = "my path";
const string destinationFileName = "my file";
string destinationFilePath = Path.Combine(destinationPath, destinationFileName);
MetadataServiceConfigurator serviceConfigurator = Factory.CreateMp4MetadataServiceConfigurator();
var metadata = new VideoMediaInfo
{
GeneralFormat = "MPEG-PS",
AudioBitRate = serviceConfigurator.AudioBps720P1Channel + 1,
AudioChannels = (int)AudioChannel.One,
AudioFormat = "AC-3",
AudioFormatProfile = null,
VideoBitRate = serviceConfigurator.VideoBps1920X1080 + 1,
VideoFormat = "MPEG Video",
VideoFrameRate = serviceConfigurator.MaxFps - 1,
VideoFormatSettingsGOP = String.Format("M=1, N={0}", serviceConfigurator.MaxKeyFrame + 1),
VideoFormatProfile = "High",
VideoWidth = 4096,
VideoHeight = 2304,
};
var metadataService = new MetadataService(serviceConfigurator, metadata);
var stringBuilder = new FfmpegService(metadataService, sourceFilePath, destinationPath, destinationFileName);
string ffmpegStr = "-i \"{0}\" -f {1} -vcodec {2} -b:v {3} -r {4} -g {5} -s {6}x{7} -profile {8} -acodec {9} -b:a {10} -quality good -cpu-used 0 -threads {11} -y \"{12}.{13}\"";
ffmpegStr = String.Format(ffmpegStr,
sourceFilePath,
metadataService.ContainerForFfmpeg,
metadataService.VideoCodecLib,
serviceConfigurator.VideoBps1920X1080,
serviceConfigurator.MaxFps - 1,
serviceConfigurator.KeyFrame,
metadata.VideoWidth,
metadata.VideoHeight,
serviceConfigurator.VideoCodec.DefaultProfile,
metadataService.AudioCodecLib,
serviceConfigurator.AudioBps720P1Channel,
Environment.ProcessorCount,
destinationFilePath,
serviceConfigurator.FfmpegContainer);
//Act
string str = stringBuilder.GetStringForEncoder();
//Assert
Assert.AreEqual(ffmpegStr, str, true);
}
private static async Task CreateConnectedAppAsync(
SalesforceConnectedServiceInstance salesforceInstance,
MetadataService metadataService,
ConnectedServiceLogger logger,
Project project)
{
salesforceInstance.ConnectedAppName = ConnectedAppHelper.GetUniqueConnectedAppName(metadataService, project);
ConnectedApp connectedApp = ConnectedAppHelper.ConstructConnectedApp(salesforceInstance, project);
SaveResult[] saveResults = metadataService.createMetadata(new Metadata[] { connectedApp });
if (ConnectedAppHelper.DoSaveResultsIndicateDuplicateValue(saveResults))
{
// The connected app failed to be created because one already exists with the specified name. This implies that the
// attempt to generate a unique name by reading the existing connected apps failed. It is unknown at this point what
// causes the Salesforce server to sometimes respond to a SOAP ReadMetadata request by returning nil for a Connected App
// name that actually exists. In this case, retry using a random number as the app name's suffix.
Debug.Fail("A connected app named '{0}' already exists. This implies that the Salesforce server responded to the SOAP ReadMetadata request to read this Connected App by returning nil for it even though it actually exists."
.FormatCurrentCulture(salesforceInstance.ConnectedAppName));
string secondAttemptConnectedAppName = ConnectedAppHelper.GetUniqueConnectedAppName(metadataService, project, true);
await logger.WriteMessageAsync(LoggerMessageCategory.Information, Resources.LogMessage_DuplicateConnectedAppName, salesforceInstance.ConnectedAppName, secondAttemptConnectedAppName);
salesforceInstance.ConnectedAppName = secondAttemptConnectedAppName;
connectedApp = ConnectedAppHelper.ConstructConnectedApp(salesforceInstance, project);
saveResults = metadataService.createMetadata(new Metadata[] { connectedApp });
}
if (saveResults.Length != 1 || !saveResults[0].success)
{
string errorMessages = saveResults.SelectMany(r => r.errors)
.Select(e => e.message)
.Aggregate((w, n) => w + "\r\n" + n);
throw new InvalidOperationException(Resources.ConnectedAppHelper_FailedToCreateConnectedApp.FormatCurrentCulture(errorMessages));
}
else
{
ConnectedApp readConnectedApp = ConnectedAppHelper.GetConnectedAppByName(connectedApp.fullName, metadataService);
if (readConnectedApp != null)
{
salesforceInstance.RuntimeAuthentication.ConsumerKey = readConnectedApp.oauthConfig.consumerKey;
}
else
{
await logger.WriteMessageAsync(LoggerMessageCategory.Warning, Resources.LogMessage_FailedReadingConnectedApp);
salesforceInstance.RuntimeAuthentication.ConsumerKey = Constants.ConfigValue_RequiredDefault;
}
}
}
public void CorectAudioValueListFillingTest()
{
//Arrange
var metadataConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
//Act
var metadataService = new MetadataService(metadataConfigurator, null);
//Assert
Assert.IsTrue(metadataService.CorrectAudioValueList.Contains(new KeyValuePair <MetadataValue, bool>(MetadataValue.AudioBps, false)));
Assert.IsTrue(metadataService.CorrectAudioValueList.Contains(new KeyValuePair <MetadataValue, bool>(MetadataValue.AudioCodec, false)));
Assert.IsTrue(metadataService.CorrectAudioValueList.Contains(new KeyValuePair <MetadataValue, bool>(MetadataValue.AudioProfile, false)));
}
public void Setup()
{
//Arrange
manager = new ConnectionManagementService(connectionString, databaseName);
metadata = new MetadataService(null, null);
branch = new BranchService();
state = new StateService();
field = new FieldService();
validation = new ValidationService();
KeyId = new KeyGenerates(8);
property = new PropertyService();
data = new DataService();
}
public virtual async Task StopAsync(CancellationToken token)
{
await StateStoreService.StopAsync(token).ConfigureAwait(false);
await MessagingService.StopAsync(token).ConfigureAwait(false);
await KeyValueStoreService.StopAsync(token).ConfigureAwait(false);
if (StorageType == MetadataStorageType.Remoting)
{
await MetadataService.StopAsync(token).ConfigureAwait(false);
}
}
public void SaveMetadataMissingMetadata()
{
var id = Guid.NewGuid();
var expectedPath = _appSettings.RepositoryPath + @"\" + _metadataMock.Valuta.Year + @"\" + id + FileSuffix;
var fileService = new Mock <IFileHandler>();
var serializationService = new Mock <ISerializationHandler>();
var metadataService = new MetadataService(fileService.Object, serializationService.Object, _appSettings);
Func <Task> t = async() =>
await metadataService.SaveMetadata(null, id);
t.Should().Throw <ArgumentNullException>();
}
public void ReadMarketDataRegistryAsync()
{
using (var httpTest = new HttpTest())
{
var mds = new MetadataService(_cfg);
var mdq = mds.ReadMarketDataRegistryAsync(100000001).ConfigureAwait(true).GetAwaiter().GetResult();
httpTest.ShouldHaveCalled($"{_cfg.BaseAddress}v2.1/marketdata/entity/100000001")
.WithVerb(HttpMethod.Get)
.Times(1);
}
}
public void GetMp4StringFromIncorrectMetadataTest()
{
//Arrange
const string sourceFilePath = "source file path";
const string destinationPath = "my path";
const string destinationFileName = "my file";
string destinationFilePath = Path.Combine(destinationPath, destinationFileName);
MetadataServiceConfigurator serviceConfigurator = Factory.CreateMp4MetadataServiceConfigurator();
var metadata = new VideoMediaInfo
{
GeneralFormat = "MPEG-PS",
AudioBitRate = serviceConfigurator.AudioBps720P1Channel + 1,
AudioChannels = (int) AudioChannel.One,
AudioFormat = "AC-3",
AudioFormatProfile = null,
VideoBitRate = serviceConfigurator.VideoBps1920X1080 + 1,
VideoFormat = "MPEG Video",
VideoFrameRate = serviceConfigurator.MaxFps - 1,
VideoFormatSettingsGOP = String.Format("M=1, N={0}", serviceConfigurator.MaxKeyFrame + 1),
VideoFormatProfile = "High",
VideoWidth = 4096,
VideoHeight = 2304,
};
var metadataService = new MetadataService(serviceConfigurator, metadata);
var stringBuilder = new FfmpegService(metadataService, sourceFilePath, destinationPath, destinationFileName);
string ffmpegStr = "-i \"{0}\" -f {1} -vcodec {2} -b:v {3} -r {4} -g {5} -s {6}x{7} -profile {8} -acodec {9} -b:a {10} -quality good -cpu-used 0 -threads {11} -y \"{12}.{13}\"";
ffmpegStr = String.Format(ffmpegStr,
sourceFilePath,
metadataService.ContainerForFfmpeg,
metadataService.VideoCodecLib,
serviceConfigurator.VideoBps1920X1080,
serviceConfigurator.MaxFps - 1,
serviceConfigurator.KeyFrame,
metadata.VideoWidth,
metadata.VideoHeight,
serviceConfigurator.VideoCodec.DefaultProfile,
metadataService.AudioCodecLib,
serviceConfigurator.AudioBps720P1Channel,
Environment.ProcessorCount,
destinationFilePath,
serviceConfigurator.FfmpegContainer);
//Act
string str = stringBuilder.GetStringForEncoder();
//Assert
Assert.AreEqual(ffmpegStr, str, true);
}
public void AdjustAudioCodecTest()
{
//Arrange
const string myCodec1 = "myCodec1";
const string myCodec2 = "myCodec2";
const string anotherCodec = "anotherCodec";
var audioCodec = new CodecData(myCodec1, null);
var supportedAudioCodecs = new List <CodecData>()
{
audioCodec,
new CodecData(myCodec2, null)
};
var serviceConfigurator = new MetadataServiceConfigurator(null, null, null, audioCodec, supportedAudioCodecs);
var metadata1 = new VideoMetadata()
{
AudioCodec = myCodec1
};
var metadata2 = new VideoMetadata()
{
AudioCodec = myCodec2
};
var metadata3 = new VideoMetadata()
{
AudioCodec = anotherCodec
};
var metadataWithoutCodec = new VideoMetadata()
{
AudioCodec = null
};
var metadataService1 = new MetadataService(serviceConfigurator, metadata1);
var metadataService2 = new MetadataService(serviceConfigurator, metadata2);
var metadataService3 = new MetadataService(serviceConfigurator, metadata3);
var metadataService4 = new MetadataService(serviceConfigurator, metadataWithoutCodec);
//Act
var codec1 = metadataService1.AdjustAudioCodec();
var codec2 = metadataService2.AdjustAudioCodec();
var codec3 = metadataService3.AdjustAudioCodec();
var codec4 = metadataService4.AdjustAudioCodec();
//Assert
Assert.AreEqual(myCodec1, codec1);
Assert.AreEqual(myCodec2, codec2);
Assert.AreEqual(myCodec1, codec3);
Assert.AreEqual(null, codec4);
}
public async void SaveMetadataValid()
{
var id = Guid.NewGuid();
var expectedPath = _appSettings.RepositoryPath + @"\" + _metadataMock.Valuta.Year + @"\" + id + FileSuffix;
var fileService = new Mock <IFileHandler>();
var serializationService = new Mock <ISerializationHandler>();
serializationService.Setup(service => service.Serialize(_metadataMock, It.IsAny <string>()));
var metadataService = new MetadataService(fileService.Object, serializationService.Object, _appSettings);
await metadataService.SaveMetadata(_metadataMock, id);
serializationService.Verify(x => x.Serialize(_metadataMock, expectedPath));
}
public ActionResult Delete(int id)
{
SecurityService.CreateAccessContext();
CFMetadataSet metadataSet = MetadataService.GetMetadataSet(id);
if (metadataSet != null)
{
Db.MetadataSets.Remove(metadataSet);
Db.SaveChanges();
}
return(RedirectToAction("index"));
}
private Dataset GetMetadataFromKartkatalogen(Dataset dataset, string uuid, bool dontUpdateDescription = false)
{
var model = new Dataset();
try
{
model = new MetadataService(db).UpdateDatasetWithMetadata(dataset, uuid, dontUpdateDescription);
}
catch (Exception e)
{
TempData["error"] = "Det oppstod en feil ved henting av metadata: " + e.Message;
}
return(model);
}
/// <summary>
/// 获取ContentItem附表数据
/// </summary>
/// <param name="contentTypeId"></param>
/// <param name="contentItemId"></param>
/// <returns></returns>
public IDictionary <string, object> GetContentItemAdditionalProperties(int contentTypeId, long contentItemId)
{
string cacheKey = "ContentItemAP:" + RealTimeCacheHelper.GetCacheKeyOfEntity(contentItemId);
IDictionary <string, object> additionalProperties = cacheService.Get <IDictionary <string, object> >(cacheKey);
if (additionalProperties == null)
{
ContentTypeDefinition contentType = new MetadataService().GetContentType(contentTypeId);
if (contentType != null)
{
additionalProperties = new Dictionary <string, object>();
Database database = CreateDAO();
database.OpenSharedConnection();
try
{
using (var cmd = database.CreateCommand(database.Connection, string.Format("SELECT * FROM {0} WHERE {1} = @0", contentType.TableName, contentType.ForeignKey), contentItemId))
{
using (IDataReader dr = cmd.ExecuteReader())
{
if (dr.Read())
{
foreach (var column in contentType.Columns)
{
if (dr[column.ColumnName] == null)
{
additionalProperties.Add(column.ColumnName, column.DefaultValue);
}
else
{
additionalProperties.Add(column.ColumnName, dr[column.ColumnName]);
}
}
}
dr.Close();
}
}
}
finally
{
database.CloseSharedConnection();
}
cacheService.Add(cacheKey, additionalProperties, CachingExpirationType.SingleObject);
}
}
return(additionalProperties);
}
public virtual async Task StartAsync(CancellationToken token)
{
if (StorageType == MetadataStorageType.Remoting)
{
await MetadataService.StartAsync(token).ConfigureAwait(false);
}
await MessagingService.StartAsync(token).ConfigureAwait(false);
ServiceInstanceHelpers.SetMessagingServiceInstance(AppDomain.CurrentDomain, MessagingService.GetInstance <IReactiveMessagingConnection>());
await StateStoreService.StartAsync(token).ConfigureAwait(false);
await KeyValueStoreService.StartAsync(token).ConfigureAwait(false);
}
public ActionResult Index()
{
const string assetsPrefix = "comparecars.index";
var metadata = MetadataService.GetMetadataForPage(HttpContext);
var viewModel = new IndexViewModel(assetsPrefix, metadata)
{
InlineHeadScript = AssetService.GetInlineHeadScript(),
InlineHeadStyles = AssetService.GetInlineHeadStyles(assetsPrefix)
};
return(View("Index", viewModel));
}
public void AdjustVideoProfileTest()
{
//Arrange
const string myCodec = "myCodec";
const string anotherProfile = "anotherProfile";
const string firstProfile = "firstProfile";
const string secondProfile = "secondProfile";
var videoCodec = new CodecData(myCodec, null, firstProfile, secondProfile);
var serviceConfigurator = new MetadataServiceConfigurator(null, null, videoCodec, null, null);
var metadata1 = new VideoMetadata()
{
VideoCodec = myCodec,
VideoProfile = firstProfile
};
var metadata2 = new VideoMetadata()
{
VideoCodec = myCodec,
VideoProfile = secondProfile
};
var metadata3 = new VideoMetadata()
{
VideoCodec = myCodec,
VideoProfile = anotherProfile
};
var metadataWithoutCodec = new VideoMetadata()
{
VideoCodec = myCodec,
VideoProfile = null
};
var metadataService1 = new MetadataService(serviceConfigurator, metadata1);
var metadataService2 = new MetadataService(serviceConfigurator, metadata2);
var metadataService3 = new MetadataService(serviceConfigurator, metadata3);
var metadataService4 = new MetadataService(serviceConfigurator, metadataWithoutCodec);
//Act
var profile1 = metadataService1.AdjustVideoProfile();
var profile2 = metadataService2.AdjustVideoProfile();
var profile3 = metadataService3.AdjustVideoProfile();
var profile4 = metadataService4.AdjustVideoProfile();
//Assert
Assert.AreEqual(firstProfile, profile1);
Assert.AreEqual(secondProfile, profile2);
Assert.AreEqual(firstProfile, profile3);
Assert.AreEqual(firstProfile, profile4);
}
public void AdjustHeightVideoSuccessTest()
{
//Arrange
var metadataConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
var metadata = new VideoMetadata()
{
Height = 100
};
var metadataService = new MetadataService(metadataConfigurator, metadata);
//Act
var adjustedHeight = metadataService.AdjustVideoHeight();
//Assert
Assert.AreEqual(metadata.Height, adjustedHeight);
}
public void AdjustWidthVideoSuccessTest()
{
//Arrange
var metadataConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
var metadata = new VideoMetadata()
{
Width = 100
};
var metadataService = new MetadataService(metadataConfigurator, metadata);
//Act
var adjustedwidth = metadataService.AdjustVideoWidth();
//Assert
Assert.AreEqual(metadata.Width, adjustedwidth);
}
public void GetMp4StringFromIncorrectMetadataTest()
{
//Arrange
const string destinationFilePath = "destination Path";
var serviceConfigurator = Factory.CreateMp4MetadataServiceConfigurator();
var metadata = new VideoMetadata()
{
Container = "MPEG-PS",
AudioBps = serviceConfigurator.AudioBps720P1Channel+1,
AudioChannel = AudioChannel.One,
AudioCodec = "AC-3",
AudioProfile = null,
VideoBps = serviceConfigurator.VideoBps1920X1080+1,
VideoCodec = "MPEG Video",
VideoFps = serviceConfigurator.MaxFps - 1,
VideoKeyFrame = serviceConfigurator.MaxKeyFrame+1,
VideoProfile = "High",
Width = 4096,
Height = 2304,
FilePath = "source file path"
};
var metadataService = new MetadataService(serviceConfigurator, metadata);
var stringBuilder = new FfmpegStringBuilder(metadataService, destinationFilePath);
var ffmpegStr = "-i \"{0}\" -f {1} -vcodec {2} -b:v {3} -r {4} -g {5} -profile {6} -acodec {7} -b:a {8} -y \"{9}.{10}\"";
ffmpegStr = String.Format(ffmpegStr,
metadata.FilePath,
metadataService.ContainerForFfmpeg,
metadataService.VideoCodecLib,
serviceConfigurator.VideoBps1920X1080,
serviceConfigurator.MaxFps - 1,
serviceConfigurator.KeyFrame,
serviceConfigurator.VideoCodec.DefaultProfile,
metadataService.AudioCodecLib,
serviceConfigurator.AudioBps720P1Channel,
destinationFilePath,
serviceConfigurator.FfmpegContainer);
//Act
var str = stringBuilder.GetStringForEncoder();
//Assert
Assert.AreEqual(ffmpegStr, str, true);
}
public void AdjustVideoBpsForVideoSizeLessConfigureMaxSizeTest()
{
//Arrange
var metadataConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
var metadata1920X1080X8000 = new VideoMediaInfo
{
VideoWidth = 1920,
VideoHeight = 1080,
VideoBitRate = metadataConfigurator.VideoBps1920X1080
};
var metadataService1 = new MetadataService(metadataConfigurator, metadata1920X1080X8000);
//Act
int adjBps1920X1080X8000 = metadataService1.AdjustVideoBps();
//Assert
Assert.AreEqual(metadataConfigurator.VideoBps1920X1080, adjBps1920X1080X8000);
}
public void Setup()
{
Connection = DbConnectionFactory.CreateTransient();
DbContext = new ApplicationDbContext(Connection);
var service = new MetadataService(DbContext);
var smashService = new SmashAttributeTypeService(DbContext);
CharactersController = new CharactersController(service);
MovesController = new MovesController(service);
MovementsController = new MovementsController(service);
SmashAttributeTypesController = new SmashAttributeTypesController(smashService);
CharacterAttributesController = new CharacterAttributesController(service);
CharacterAttributeTypesController = new CharacterAttributeTypesController(service);
NotationsController = new NotationsController(service);
CalculatorController = new CalculatorController(DbContext);
TestObjects = new TestObjects();
//Startup.ConfigureAutoMapping();
}
public void AdjustWidtVideoFailTest()
{
//Arrange
var metadataConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
var metadata1 = new VideoMetadata()
{
Width = 0
};
var metadata2 = new VideoMetadata()
{
Width = -1
};
var metadataService1 = new MetadataService(metadataConfigurator, metadata1);
var metadataService2 = new MetadataService(metadataConfigurator, metadata2);
//Act & Assert
CustomAssert.IsThrown<MediaFormatException>(() => metadataService1.AdjustVideoWidth());
CustomAssert.IsThrown<MediaFormatException>(() => metadataService2.AdjustVideoWidth());
}
private void StartEncode(MetadataServiceConfigurator serviceConfigurator, string[] filePathes)
{
var allSw = new Stopwatch();
var decodeSw = new Stopwatch();
foreach (var filePath in filePathes)
{
allSw.Start();
Trace.WriteLine(String.Format("\n-------------Start decode file: {0}-------------\n", filePath));
try
{
var destinationFilePath = GetDestinationFilePath(filePath);
var mediaInfo = new MediaInfoWrapper();
var metadataInfo = new VideoMetadataInfo(mediaInfo);
var metadata = metadataInfo.GetMetadata(filePath);
var metadataService = new MetadataService(serviceConfigurator, metadata);
var stringBuilder = new FfmpegStringBuilder(metadataService, destinationFilePath);
var ffmpeg = new Ffmpeg(stringBuilder);
var ffmpegString = stringBuilder.GetStringForEncoder();
WriteFileInfo(ffmpegString, metadata);
decodeSw.Start();
var result = ffmpeg.StartEncodeProcess();
allSw.Stop();
decodeSw.Stop();
WriteFinishProcess(decodeSw.Elapsed, allSw.Elapsed, result);
}
catch (MediaFormatException ex)
{
Trace.WriteLine(String.Format("Error File: {0}. Error Param: {1}", ex.VideoUri, ex.InvalidParameter));
}
finally
{
Trace.WriteLine(String.Format("\n-------------Finish decode file: {0}-------------\n", filePath));
}
}
}
public void AdjustAudioBpsForVideoSizeMoreConfigureMaxSizeTest()
{
//Arrange
var metadataConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
metadataConfigurator.MaxWidth = 854;
metadataConfigurator.MaxHeight = 480;
var metadata128Bps = new VideoMediaInfo
{
VideoWidth = 1920,
VideoHeight = 1080,
AudioChannels = (int) AudioChannel.One,
AudioBitRate = metadataConfigurator.AudioBps720P1Channel
};
var metadataService1 = new MetadataService(metadataConfigurator, metadata128Bps);
//Act
int adjBps = metadataService1.AdjustAudioBps();
//Assert
Assert.AreEqual(metadataConfigurator.AudioBps360P1Channel, adjBps);
}
public void EncodedVideoMetadataTest()
{
//Arrange
const string sourceFilePath = "source file path";
const string destinationPath = "my path";
const string destinationFileName = "my file";
MetadataServiceConfigurator serviceConfigurator = Factory.CreateMp4MetadataServiceConfigurator();
var metadata = new VideoMediaInfo
{
GeneralFormat = "MPEG-PS",
AudioBitRate = serviceConfigurator.AudioBps720P1Channel + 1,
AudioChannels = (int) AudioChannel.One,
AudioFormat = "AC-3",
AudioFormatProfile = null,
VideoBitRate = serviceConfigurator.VideoBps1920X1080 + 1,
VideoFormat = "MPEG Video",
VideoFrameRate = serviceConfigurator.MaxFps - 1,
VideoFormatSettingsGOP = String.Format("M=1, N={0}", serviceConfigurator.MaxKeyFrame + 1),
VideoFormatProfile = "High",
VideoWidth = 4096,
VideoHeight = 2304,
};
var metadataService = new MetadataService(serviceConfigurator, metadata);
var ffmpegService = new FfmpegService(metadataService, sourceFilePath, destinationPath, destinationFileName);
//Act
ffmpegService.GetStringForEncoder();
//Assert
Assert.AreEqual(ffmpegService.EncodedVideoData.Container, serviceConfigurator.Container);
Assert.AreEqual(ffmpegService.EncodedVideoData.Width, metadata.VideoWidth);
Assert.AreEqual(ffmpegService.EncodedVideoData.Height, metadata.VideoHeight);
Assert.AreEqual(ffmpegService.EncodedVideoData.VideoCodec, serviceConfigurator.VideoCodec.Codec);
Assert.AreEqual(ffmpegService.EncodedVideoData.AudioCodec, serviceConfigurator.AudioCodec.Codec);
}
public void AdjustVideoCodecTest()
{
//Arrange
const string anotherCodecName = "anotherCodec";
const string myCodecName = "myCodec";
var myCodec = new CodecData(myCodecName, null);
var serviceConfigurator = new MetadataServiceConfigurator(null, null, myCodec, null, null);
var metadata1 = new VideoMetadata()
{
VideoCodec = myCodecName
};
var metadata2 = new VideoMetadata()
{
VideoCodec = anotherCodecName
};
var metadataWithoutCodec = new VideoMetadata()
{
VideoCodec = null
};
var metadataService1 = new MetadataService(serviceConfigurator, metadata1);
var metadataService2 = new MetadataService(serviceConfigurator, metadata2);
var metadataService3 = new MetadataService(serviceConfigurator, metadataWithoutCodec);
//Act
var codec1 = metadataService1.AdjustVideoCodec();
var codec2 = metadataService2.AdjustVideoCodec();
//Act & Assert
CustomAssert.IsThrown<MediaFormatException>(() => metadataService3.AdjustContainer());
//Assert
Assert.AreEqual(myCodecName, codec1);
Assert.AreEqual(myCodecName, codec2);
}
public void AdjustVideoFpsSuccessTest()
{
//Arrange
var metadataConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
var metadata1 = new VideoMetadata()
{
VideoFps = 29.970
};
var metadata2 = new VideoMetadata()
{
VideoFps = metadataConfigurator.MinFps - 1
};
var metadata3 = new VideoMetadata()
{
VideoFps = metadataConfigurator.MaxFps + 1
};
var metadataService1 = new MetadataService(metadataConfigurator, metadata1);
var metadataService2 = new MetadataService(metadataConfigurator, metadata2);
var metadataService3 = new MetadataService(metadataConfigurator, metadata3);
//Act
var adjustedFps1 = metadataService1.AdjustVideoFps();
//Act & Assert
CustomAssert.IsThrown<MediaFormatException>(() => metadataService2.AdjustVideoFps());
CustomAssert.IsThrown<MediaFormatException>(() =>metadataService3.AdjustVideoFps());
//Assert
Assert.AreEqual(metadata1.VideoFps, adjustedFps1);
}
public void AdjustVideoKeyFrameSuccessTest()
{
//Arrange
var serviceConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
int myKeyFrame = serviceConfigurator.MaxKeyFrame - 1;
var metadataKeyFrame0 = new VideoMediaInfo
{
VideoFormatSettingsGOP = String.Format("M=1, N={0}", serviceConfigurator.MinKeyFrame - 1)
};
var metadataKeyFrameMore60 = new VideoMediaInfo
{
VideoFormatSettingsGOP = String.Format("M=1, N={0}", serviceConfigurator.MaxKeyFrame + 1)
};
var metadataKeyFrame = new VideoMediaInfo
{
VideoFormatSettingsGOP = String.Format("M=1, N={0}", myKeyFrame)
};
var metadataService1 = new MetadataService(serviceConfigurator, metadataKeyFrame0);
var metadataService2 = new MetadataService(serviceConfigurator, metadataKeyFrameMore60);
var metadataService3 = new MetadataService(serviceConfigurator, metadataKeyFrame);
//Act;
int keyFrame0 = metadataService1.AdjustKeyFrame();
int keyFrameMore60 = metadataService2.AdjustKeyFrame();
int keyFrame = metadataService3.AdjustKeyFrame();
//Assert
Assert.AreEqual(serviceConfigurator.KeyFrame, keyFrame0);
Assert.AreEqual(serviceConfigurator.KeyFrame, keyFrameMore60);
Assert.AreEqual(myKeyFrame, keyFrame);
}
public void AdjustVideoBpsForLess640X360SuccessTest()
{
//Arrange
var metadataConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
var metadata1000Bps = new VideoMetadata()
{
Width = 40,
Height = 60,
VideoBps = metadataConfigurator.VideoBps640X360
};
var metadataMore1000Bps = new VideoMetadata()
{
Width = 40,
Height = 60,
VideoBps = metadataConfigurator.VideoBps640X360 + 1
};
var metadataLess1000Bps = new VideoMetadata()
{
Width = 40,
Height = 60,
VideoBps = metadataConfigurator.VideoBps640X360 - 1
};
var metadataService1 = new MetadataService(metadataConfigurator, metadata1000Bps);
var metadataService2 = new MetadataService(metadataConfigurator, metadataMore1000Bps);
var metadataService3 = new MetadataService(metadataConfigurator, metadataLess1000Bps);
//Act
var adjBps1000Bps = metadataService1.AdjustVideoBps();
var adjBpsMore1000Bps = metadataService2.AdjustVideoBps();
var adjBpsLess1000Bps = metadataService3.AdjustVideoBps();
//Assert
Assert.AreEqual(metadataConfigurator.VideoBps640X360, adjBps1000Bps);
Assert.AreEqual(metadataConfigurator.VideoBps640X360, adjBpsMore1000Bps);
Assert.AreEqual(metadataLess1000Bps.VideoBps, adjBpsLess1000Bps);
}
public void AdjustVideoBpsFor854X480SuccessTest()
{
//Arrange
var metadataConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
var metadata854X480X2500 = new VideoMetadata()
{
Width = 854,
Height = 480,
VideoBps = metadataConfigurator.VideoBps854X480
};
var metadata854X480More2500 = new VideoMetadata()
{
Width = 854,
Height = 480,
VideoBps = metadataConfigurator.VideoBps854X480 + 1
};
var metadata854X480Less2500 = new VideoMetadata()
{
Width = 854,
Height = 480,
VideoBps = metadataConfigurator.VideoBps854X480 - 1
};
var metadataService1 = new MetadataService(metadataConfigurator, metadata854X480X2500);
var metadataService2 = new MetadataService(metadataConfigurator, metadata854X480More2500);
var metadataService3 = new MetadataService(metadataConfigurator, metadata854X480Less2500);
//Act
var adjBps854X480X2500 = metadataService1.AdjustVideoBps();
var adjBps854X480More2500 = metadataService2.AdjustVideoBps();
var adjBps854X480Less2500 = metadataService3.AdjustVideoBps();
//Assert
Assert.AreEqual(metadataConfigurator.VideoBps854X480, adjBps854X480X2500);
Assert.AreEqual(metadataConfigurator.VideoBps854X480, adjBps854X480More2500);
Assert.AreEqual(metadata854X480Less2500.VideoBps, adjBps854X480Less2500);
}
public void AdjustAudioBpsFor854X480And640X360AndLessX6ChannelSuccessTest()
{
//Arrange
var metadataConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
var metadata64Bps = new VideoMetadata()
{
Width = 640,
Height = 360,
AudioChannel = AudioChannel.Six,
AudioBps = metadataConfigurator.AudioBps360P6Channel
};
var metadataMore64Bps = new VideoMetadata()
{
Width = 640,
Height = 360,
AudioChannel = AudioChannel.Six,
AudioBps = metadataConfigurator.AudioBps360P6Channel + 1
};
var metadataLess64Bps = new VideoMetadata()
{
Width = 640,
Height = 360,
AudioChannel = AudioChannel.Six,
AudioBps = metadataConfigurator.AudioBps360P6Channel - 1
};
var metadataService1 = new MetadataService(metadataConfigurator, metadata64Bps);
var metadataService2 = new MetadataService(metadataConfigurator, metadataMore64Bps);
var metadataService3 = new MetadataService(metadataConfigurator, metadataLess64Bps);
//Act
var adjBps64Bps = metadataService1.AdjustAudioBps();
var adjBpsMore64Bps = metadataService2.AdjustAudioBps();
var adjBpsLess64Bps = metadataService3.AdjustAudioBps();
//Assert
Assert.AreEqual(metadataConfigurator.AudioBps360P6Channel, adjBps64Bps);
Assert.AreEqual(metadataConfigurator.AudioBps360P6Channel, adjBpsMore64Bps);
Assert.AreEqual(metadataLess64Bps.AudioBps, adjBpsLess64Bps);
}
public void AdjustAudioBpsFor1920X1080And1280X720X6ChannelSuccessTest()
{
//Arrange
var metadataConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
var metadata512Bps = new VideoMetadata()
{
Width = 1280,
Height = 720,
AudioChannel = AudioChannel.Six,
AudioBps = metadataConfigurator.AudioBps720P6Channel
};
var metadataMore512Bps = new VideoMetadata()
{
Width = 1280,
Height = 720,
AudioChannel = AudioChannel.Six,
AudioBps = metadataConfigurator.AudioBps720P6Channel + 1
};
var metadataLess512Bps = new VideoMetadata()
{
Width = 1280,
Height = 720,
AudioChannel = AudioChannel.Six,
AudioBps = metadataConfigurator.AudioBps720P6Channel - 1
};
var metadataService1 = new MetadataService(metadataConfigurator, metadata512Bps);
var metadataService2 = new MetadataService(metadataConfigurator, metadataMore512Bps);
var metadataService3 = new MetadataService(metadataConfigurator, metadataLess512Bps);
//Act
var adjBps512Bps = metadataService1.AdjustAudioBps();
var adjBpsMore512Bps = metadataService2.AdjustAudioBps();
var adjBpsLess512Bps = metadataService3.AdjustAudioBps();
//Assert
Assert.AreEqual(metadataConfigurator.AudioBps720P6Channel, adjBps512Bps);
Assert.AreEqual(metadataConfigurator.AudioBps720P6Channel, adjBpsMore512Bps);
Assert.AreEqual(metadataLess512Bps.AudioBps, adjBpsLess512Bps);
}
private Container()
{
var builder = new ContainerBuilder();
builder.RegisterType<ApplicationDbContext>()
.As<IApplicationDbContext>();
const string metadataServiceName = "metadataService";
var context = new ApplicationDbContext();
var metadataResultValidationService = new ResultValidationService();
var metadataService = new MetadataService(context, metadataResultValidationService);
builder.RegisterType<AnglesController>()
.As<AnglesController>()
.WithParameter(metadataServiceName, metadataService);
builder.RegisterType<BaseDamagesController>()
.As<BaseDamagesController>()
.WithParameter(metadataServiceName, metadataService);
builder.RegisterType<CharacterAttributesController>()
.As<CharacterAttributesController>()
.WithParameter(metadataServiceName, metadataService);
builder.RegisterType<CharacterAttributeTypesController>()
.As<CharacterAttributeTypesController>()
.WithParameter(metadataServiceName, metadataService);
builder.RegisterType<CharactersController>()
.As<CharactersController>()
.WithParameter(metadataServiceName, metadataService);
builder.RegisterType<HitboxesController>()
.As<HitboxesController>()
.WithParameter(metadataServiceName, metadataService);
builder.RegisterType<KnockbackGrowthsController>()
.As<KnockbackGrowthsController>()
.WithParameter(metadataServiceName, metadataService);
builder.RegisterType<MovementsController>()
.As<MovementsController>()
.WithParameter(metadataServiceName, metadataService);
builder.RegisterType<MovesController>()
.As<MovesController>()
.WithParameter(metadataServiceName, metadataService);
builder.RegisterType<NotationsController>()
.As<NotationsController>()
.WithParameter(metadataServiceName, metadataService);
builder.RegisterType<SmashAttributeTypesController>()
.As<SmashAttributeTypesController>()
.WithParameter("smashAttributeTypesService", new SmashAttributeTypeService(context, metadataResultValidationService));
builder.RegisterType<ThrowsController>()
.As<ThrowsController>()
.WithParameter(metadataServiceName, metadataService);
builder.RegisterType<ThrowTypesController>()
.As<ThrowTypesController>()
.WithParameter(metadataServiceName, metadataService);
builder.RegisterType<BaseKnockbacksController>()
.As<BaseKnockbacksController>()
.WithParameter(metadataServiceName, metadataService);
builder.RegisterType<SetKnockbacksController>()
.As<SetKnockbacksController>()
.WithParameter(metadataServiceName, metadataService);
builder.RegisterApiControllers();
builder.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource());
builder.RegisterType<IApplicationDbContext>()
.AsImplementedInterfaces()
.InstancePerLifetimeScope();
_container = builder.Build();
}
public void AdjustVideoKeyFrameSuccessTest()
{
//Arrange
var metadataConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
var metadataKeyFrame0 = new VideoMetadata()
{
VideoKeyFrame = metadataConfigurator.MinKeyFrame - 1
};
var metadataKeyFrameMore60 = new VideoMetadata()
{
VideoKeyFrame = metadataConfigurator.MaxKeyFrame + 1
};
var metadataKeyFrame = new VideoMetadata()
{
VideoKeyFrame = 30
};
var metadataService1 = new MetadataService(metadataConfigurator, metadataKeyFrame0);
var metadataService2 = new MetadataService(metadataConfigurator, metadataKeyFrameMore60);
var metadataService3 = new MetadataService(metadataConfigurator, metadataKeyFrame);
//Act;
var keyFrame0 = metadataService1.AdjustKeyFrame();
var keyFrameMore60 = metadataService2.AdjustKeyFrame();
var keyFrame = metadataService3.AdjustKeyFrame();
//Assert
Assert.AreEqual(metadataConfigurator.KeyFrame, keyFrame0);
Assert.AreEqual(metadataConfigurator.KeyFrame, keyFrameMore60);
Assert.AreEqual(metadataKeyFrame.VideoKeyFrame, keyFrame);
}
public void AdjustAudioCodecTest()
{
//Arrange
const string myCodec1 = "myCodec1";
const string myCodec2 = "myCodec2";
const string anotherCodec = "anotherCodec";
var audioCodec = new CodecData(myCodec1, null);
var supportedAudioCodecs = new List<CodecData>()
{
audioCodec,
new CodecData(myCodec2, null)
};
var serviceConfigurator = new MetadataServiceConfigurator(null, null, null, audioCodec, supportedAudioCodecs);
var metadata1 = new VideoMetadata()
{
AudioCodec = myCodec1
};
var metadata2 = new VideoMetadata()
{
AudioCodec = myCodec2
};
var metadata3 = new VideoMetadata()
{
AudioCodec = anotherCodec
};
var metadataWithoutCodec = new VideoMetadata()
{
AudioCodec = null
};
var metadataService1 = new MetadataService(serviceConfigurator, metadata1);
var metadataService2 = new MetadataService(serviceConfigurator, metadata2);
var metadataService3 = new MetadataService(serviceConfigurator, metadata3);
var metadataService4 = new MetadataService(serviceConfigurator, metadataWithoutCodec);
//Act
var codec1 = metadataService1.AdjustAudioCodec();
var codec2 = metadataService2.AdjustAudioCodec();
var codec3 = metadataService3.AdjustAudioCodec();
var codec4 = metadataService4.AdjustAudioCodec();
//Assert
Assert.AreEqual(myCodec1, codec1);
Assert.AreEqual(myCodec2, codec2);
Assert.AreEqual(myCodec1, codec3);
Assert.AreEqual(null, codec4);
}
public void AdjustContainerTest()
{
//Arrange
const string myContainer = "myContainer";
const string anotherContainer = "anotherContainer";
var serviceConfigurator = new MetadataServiceConfigurator(myContainer, null, null, null, null);
var metadata1 = new VideoMetadata()
{
Container = myContainer
};
var metadata2 = new VideoMetadata()
{
Container = anotherContainer
};
var metadataWithoutContainer = new VideoMetadata()
{
Container = null
};
var metadataService1 = new MetadataService(serviceConfigurator, metadata1);
var metadataService2 = new MetadataService(serviceConfigurator, metadata2);
var metadataService3 = new MetadataService(serviceConfigurator, metadataWithoutContainer);
//Act
var container1 = metadataService1.AdjustContainer();
var container2 = metadataService2.AdjustContainer();
//Act & Assert
CustomAssert.IsThrown<MediaFormatException>(() => metadataService3.AdjustContainer());
//Assert
Assert.AreEqual(myContainer, container1);
Assert.AreEqual(myContainer, container2);
}
public void CorectAudioValueListFillingTest()
{
//Arrange
var metadataConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
//Act
var metadataService = new MetadataService(metadataConfigurator, null);
//Assert
Assert.IsTrue(metadataService.CorrectAudioValueList.Contains(new KeyValuePair<MetadataValue, bool>(MetadataValue.AudioBps, false)));
Assert.IsTrue(metadataService.CorrectAudioValueList.Contains(new KeyValuePair<MetadataValue, bool>(MetadataValue.AudioCodec, false)));
Assert.IsTrue(metadataService.CorrectAudioValueList.Contains(new KeyValuePair<MetadataValue, bool>(MetadataValue.AudioProfile, false)));
}
public void CheckCorrectContainerTest()
{
//Arrange
var serviceConfigurator = Factory.CreateMp4MetadataServiceConfigurator();
var metadata = new VideoMetadata()
{
Container = serviceConfigurator.Container
};
var metadataService = new MetadataService(serviceConfigurator, metadata);
//Act
metadataService.AdjustContainer();
//Assert
Assert.IsTrue(metadataService.CorrectContainer);
}
public void CheckCorrectAudioValueListTest()
{
//Arrange
var serviceConfigurator = Factory.CreateMp4MetadataServiceConfigurator();
var metadata = new VideoMetadata()
{
AudioBps = serviceConfigurator.AudioBps720P1Channel,
AudioChannel = AudioChannel.One,
AudioCodec = "AAC",
AudioProfile = "LC",
VideoBps = serviceConfigurator.VideoBps1920X1080,
VideoCodec = "AVC",
VideoProfile = "Baseline",
VideoFps = serviceConfigurator.MaxFps - 1,
VideoKeyFrame = serviceConfigurator.KeyFrame,
Width = 4096,
Height = 2304
};
var metadataService = new MetadataService(serviceConfigurator, metadata);
//Act
metadataService.AdjustAudioBps();
metadataService.AdjustAudioCodec();
metadataService.AdjustAudioProfile();
//Assert
Assert.IsTrue(metadataService.CorrectAudioValueList.All((b) => b.Value));
}
public void AdjustScreenshotTimeTest()
{
//Arrange
var serviceConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
var metadata1 = new VideoMetadata()
{
Duration = (int)serviceConfigurator.ScreenshotTime.TotalMilliseconds - 1
};
var metadata2 = new VideoMetadata()
{
Duration = (int)serviceConfigurator.ScreenshotTime.TotalMilliseconds + 1
};
var metadataService1 = new MetadataService(serviceConfigurator, metadata1);
var metadataService2 = new MetadataService(serviceConfigurator, metadata2);
//Act
var time1 = metadataService1.AdjustScreenshotTime();
var time2 = metadataService2.AdjustScreenshotTime();
//Assert
Assert.AreEqual(0, time1);
Assert.AreEqual((int)serviceConfigurator.ScreenshotTime.Seconds, time2);
}
public void AdjustAudioProfileTest()
{
//Arrange
const string myCodec1 = "myCodec1";
const string myCodec2 = "myCodec2";
const string anotherProfile = "anotherProfile";
const string firstProfile = "firstProfile";
var audioCodec = new CodecData(myCodec1, null, firstProfile);
var supportedAudioCodecs = new List<CodecData>()
{
audioCodec,
new CodecData(myCodec2,null)
};
var serviceConfigurator = new MetadataServiceConfigurator(null, null, null, audioCodec, supportedAudioCodecs);
var metadata1 = new VideoMetadata()
{
AudioCodec = myCodec1,
AudioProfile = firstProfile
};
var metadata2 = new VideoMetadata()
{
AudioCodec = myCodec1,
AudioProfile = anotherProfile
};
var metadata3 = new VideoMetadata()
{
AudioCodec = myCodec2,
AudioProfile = anotherProfile
};
var metadataWithoutProfile = new VideoMetadata()
{
AudioCodec = myCodec1,
AudioProfile = null
};
var metadataService1 = new MetadataService(serviceConfigurator, metadata1);
var metadataService2 = new MetadataService(serviceConfigurator, metadata2);
var metadataService3 = new MetadataService(serviceConfigurator, metadata3);
var metadataService4 = new MetadataService(serviceConfigurator, metadataWithoutProfile);
//Act
var profile1 = metadataService1.AdjustAudioProfile();
var profile2 = metadataService2.AdjustAudioProfile();
var profile3 = metadataService3.AdjustAudioProfile();
var profile4 = metadataService4.AdjustAudioProfile();
//Assert
Assert.AreEqual(firstProfile, profile1);
Assert.AreEqual(firstProfile, profile2);
Assert.AreEqual(anotherProfile, profile3);
Assert.AreEqual(firstProfile, profile4);
}
public void AdjustVideoBpsFor1280X720SuccessTest()
{
//Arrange
var metadataConfigurator = new MetadataServiceConfigurator(null, null, null, null, null);
var metadata1280X720X5000 = new VideoMetadata()
{
Width = 1280,
Height = 720,
VideoBps = metadataConfigurator.VideoBps1280X720
};
var metadata1280X720More5000 = new VideoMetadata()
{
Width = 1280,
Height = 720,
VideoBps = metadataConfigurator.VideoBps1280X720 + 1
};
var metadata1280X720Less5000 = new VideoMetadata()
{
Width = 1280,
Height = 720,
VideoBps = metadataConfigurator.VideoBps1280X720 - 1
};
var metadataService1 = new MetadataService(metadataConfigurator, metadata1280X720X5000);
var metadataService2 = new MetadataService(metadataConfigurator, metadata1280X720More5000);
var metadataService3 = new MetadataService(metadataConfigurator, metadata1280X720Less5000);
//Act
var adjBps1280X720X5000 = metadataService1.AdjustVideoBps();
var adjBps1280X720More5000 = metadataService2.AdjustVideoBps();
var adjBps1280X720Less5000 = metadataService3.AdjustVideoBps();
//Assert
Assert.AreEqual(metadataConfigurator.VideoBps1280X720, adjBps1280X720X5000);
Assert.AreEqual(metadataConfigurator.VideoBps1280X720, adjBps1280X720More5000);
Assert.AreEqual(metadata1280X720Less5000.VideoBps, adjBps1280X720Less5000);
}
public void AdjustVideoProfileTest()
{
//Arrange
const string myCodec = "myCodec";
const string anotherProfile = "anotherProfile";
const string firstProfile = "firstProfile";
const string secondProfile = "secondProfile";
var videoCodec = new CodecData(myCodec, null, firstProfile, secondProfile);
var serviceConfigurator = new MetadataServiceConfigurator(null, null, videoCodec, null, null);
var metadata1 = new VideoMetadata()
{
VideoCodec = myCodec,
VideoProfile = firstProfile
};
var metadata2 = new VideoMetadata()
{
VideoCodec = myCodec,
VideoProfile = secondProfile
};
var metadata3 = new VideoMetadata()
{
VideoCodec = myCodec,
VideoProfile = anotherProfile
};
var metadataWithoutCodec = new VideoMetadata()
{
VideoCodec = myCodec,
VideoProfile = null
};
var metadataService1 = new MetadataService(serviceConfigurator, metadata1);
var metadataService2 = new MetadataService(serviceConfigurator, metadata2);
var metadataService3 = new MetadataService(serviceConfigurator, metadata3);
var metadataService4 = new MetadataService(serviceConfigurator, metadataWithoutCodec);
//Act
var profile1 = metadataService1.AdjustVideoProfile();
var profile2 = metadataService2.AdjustVideoProfile();
var profile3 = metadataService3.AdjustVideoProfile();
var profile4 = metadataService4.AdjustVideoProfile();
//Assert
Assert.AreEqual(firstProfile, profile1);
Assert.AreEqual(secondProfile, profile2);
Assert.AreEqual(firstProfile, profile3);
Assert.AreEqual(firstProfile, profile4);
}
