private bool rdprfxNegativeTest(RdprfxNegativeType negType)
{
StartRDPConnection();
this.rdprfxAdapter.SetTestType(negType);
#region Fill parameters
TS_RFX_ICAP[] clientSupportedCaps;
rdprfxAdapter.ReceiveAndCheckClientCapabilities(maxRequestSize, out clientSupportedCaps);
OperationalMode opMode = OperationalMode.ImageMode;
EntropyAlgorithm enAlgorithm = EntropyAlgorithm.CLW_ENTROPY_RLGR3;
ushort destLeft = 0; //the left bound of the frame.
ushort destTop = 0; //the top bound of the frame.
//Set OperationalMode/EntropyAlgorithm to valid pair.
if (clientSupportedCaps != null)
{
opMode = (OperationalMode)clientSupportedCaps[0].flags;
enAlgorithm = (EntropyAlgorithm)clientSupportedCaps[0].entropyBits;
}
#endregion
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending one frame of encoded bitmap data to client. Operational Mode = {0}, Entropy Algorithm = {1}, destLeft = {2}, destTop = {3}.",
opMode, enAlgorithm, destLeft, destTop);
this.rdprfxAdapter.SendImageToClient(image_64X64, opMode, enAlgorithm, destLeft, destTop);
bool fDisconnected = this.rdpbcgrAdapter.WaitForDisconnection(waitTime);
StopRDPConnection();
return(fDisconnected);
}
/// <summary>
/// Method to send one frame of encoded data message to client.
/// </summary>
/// <param name="image">The image to be sent.</param>
/// <param name="opMode">Indicates the operational mode.</param>
/// <param name="entropy">Indicates the entropy algorithm.</param>
/// <param name="destLeft">Left bound of the frame.</param>
/// <param name="destTop">Left bound of the frame.</param>
public void SendImageToClient(System.Drawing.Image image, OperationalMode opMode, EntropyAlgorithm entropy, ushort destLeft, ushort destTop)
{
if (image == null)
{
Site.Log.Add(LogEntryKind.Debug, "[In iRdprfxAdapter.SendImageToClient Method] The image to be send is null.");
return;
}
TileImage[] tileImageArr = RdprfxTileUtils.SplitToTileImage(image, RdprfxServer.TileSize, RdprfxServer.TileSize);
for (int idx = 0; idx < tileImageArr.Length; idx++)
{
if (idx == 0 || opMode == OperationalMode.ImageMode)
{
SendTsRfxSync();
SendTsRfxCodecVersions();
SendTsRfxChannels();
SendTsRfxContext(opMode, entropy);
}
SendTsRfxFrameBegin((uint)idx);
SendTsRfxRegion();
SendTsRfxTileSet(opMode, entropy, tileImageArr[idx].image);
SendTsRfxFrameEnd();
FlushEncodedData((ushort)(destLeft + tileImageArr[idx].x), (ushort)(destTop + tileImageArr[idx].y));
if (currentTestType != RdprfxNegativeType.None)
{
// Only send one message if it is in a negative test case.
break;
}
}
}
/// <summary>
/// Method to create TS_RFX_CONTEXT.
/// </summary>
/// <param name="isImageMode">Indicates the operational mode.</param>
/// <param name="entropy">Indicates the entropy algorithm.</param>
public TS_RFX_CONTEXT CreateTsRfxContext(OperationalMode opMode, EntropyAlgorithm entropy)
{
TS_RFX_CONTEXT rfxContext = new TS_RFX_CONTEXT();
rfxContext.CodecChannelT = new TS_RFX_CODEC_CHANNELT();
rfxContext.CodecChannelT.blockType = blockType_Value.WBT_CONTEXT;
rfxContext.CodecChannelT.blockLen = 13;
rfxContext.CodecChannelT.codecId = 0x01;
rfxContext.CodecChannelT.channelId = 0x00;
rfxContext.ctxId = 0x00;
rfxContext.tileSize = 0x0040;
ushort flags = 0x0002;
if (opMode == OperationalMode.VideoMode) flags = 0x0000;
ushort cct = 0x0001;
ushort xft = 0x0001;
ushort et = 0x0001;
if (entropy == EntropyAlgorithm.CLW_ENTROPY_RLGR3) et = 0x0004;
ushort qt = 0x0001;
ushort r = 0x0000;
rfxContext.properties = 0x0000;
rfxContext.properties |= flags;
rfxContext.properties |= (ushort)(cct << 3);
rfxContext.properties |= (ushort)(xft << 5);
rfxContext.properties |= (ushort)(et << 9);
rfxContext.properties |= (ushort)(qt << 13);
rfxContext.properties |= (ushort)(r << 15);
return rfxContext;
}
private TurnOnRequestedMessage(OperationalMode requestedOperationalMode, int?desiredTemperature, TimeSpan?desiredDuration)
{
RequestedOperationalMode = requestedOperationalMode;
_desiredDuration = desiredDuration;
_desiredTemperature = desiredTemperature;
}
/// <summary>
/// Using RDPRFX to send image whose resolution is Width x Height
/// </summary>
/// <param name="imagefile">Image to send</param>
/// <param name="width">Width of image to send</param>
/// <param name="height">Height of image to send</param>
public bool RdprfxSendImage(Image image, ushort width, ushort height)
{
uint frameId = 0; //The index of the sending frame.
OperationalMode opMode = OperationalMode.ImageMode;
EntropyAlgorithm enAlgorithm = EntropyAlgorithm.CLW_ENTROPY_RLGR1;
ushort destLeft = 0; //the left bound of the frame.
ushort destTop = 0; //the top bound of the frame.
// Crop Image
Bitmap bitmap = new Bitmap(width, height);
Graphics graphics = Graphics.FromImage(bitmap);
Rectangle section = new Rectangle(0, 0, width, height);
graphics.DrawImage(image, 0, 0, section, GraphicsUnit.Pixel);
//Check if the above setting is supported by the client.
if (!this.rdprfxAdapter.CheckIfClientSupports(opMode, enAlgorithm))
{
return(false);
}
rdpbcgrAdapter.SendFrameMarkerCommand(frameAction_Values.SURFACECMD_FRAMEACTION_BEGIN, frameId);
rdprfxAdapter.SendImageToClient(bitmap, opMode, enAlgorithm, destLeft, destTop);
rdpbcgrAdapter.SendFrameMarkerCommand(frameAction_Values.SURFACECMD_FRAMEACTION_END, frameId);
rdprfxAdapter.ExpectTsFrameAcknowledgePdu(frameId, waitTime);
return(true);
}
/// <summary>
/// Method to send TS_RFX_CONTEXT to client.
/// </summary>
/// <param name="isImageMode">Indicates the operational mode.</param>
/// <param name="entropy">Indicates the entropy algorithm.</param>
public void SendTsRfxContext(OperationalMode opMode, EntropyAlgorithm entropy)
{
this.admEntropyAlgorithm = entropy;
this.admOperationMode = opMode;
TS_RFX_CONTEXT rfxContext = rdprfxServer.CreateTsRfxContext(opMode, entropy);
if (this.currentTestType == RdprfxNegativeType.TsRfxContext_InvalidCtxId)
{
rfxContext.ctxId = 0x01; //set to an invalid value other than 0x00.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxContext_InvalidTileSize)
{
rfxContext.tileSize = 0x0080; //set to an invalid value other than 0x0040.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxContext_InvalidCct)
{
rfxContext.properties &= 0xFFF7; //set "cct" to an invalid value: 0x0.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxContext_InvalidXft)
{
rfxContext.properties &= 0xFE1F; //set "xft" to an invalid value: 0x0.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxContext_InvalidQt)
{
rfxContext.properties &= 0x9FFF; //set "qt" to an invalid value: 0x0.
}
AddToPendingList(rfxContext);
}
public LuceneIndexImplementation(DatabaseLayout databaseLayout, Config config, System.Func <IndexConfigStore> indexStore, FileSystemAbstraction fileSystemAbstraction, OperationalMode operationalMode)
{
this._databaseLayout = databaseLayout;
this._config = config;
this._indexStore = indexStore;
this._fileSystemAbstraction = fileSystemAbstraction;
this._operationalMode = operationalMode;
}
/// <summary>
/// Constructs this data source.
/// </summary>
public LuceneDataSource(DatabaseLayout directoryStructure, Config config, IndexConfigStore indexStore, FileSystemAbstraction fileSystemAbstraction, OperationalMode operationalMode)
{
this._directoryStructure = directoryStructure;
this._config = config;
this._indexStore = indexStore;
this._typeCache = new IndexTypeCache(indexStore);
this._fileSystemAbstraction = fileSystemAbstraction;
this._operationalMode = operationalMode;
}
protected void btnDrawMode_onClick(MouseEventArgs eventArgs)
{
OperationalMode prevMode = CurrOperationalMode;
CurrOperationalMode = OperationalMode.draw;
if (CurrOperationalMode != prevMode)
{
OperationalModeHasChanged();
}
}
/// <summary>
/// Write the device configuration to the ASCOM Profile store
/// </summary>
internal void WriteProfile()
{
using (Profile driverProfile = new Profile()
{
DeviceType = "ObservingConditions"
})
{
driverProfile.WriteValue(DriverId, VantagePro_OpMode, OperationalMode.ToString());
driverProfile.WriteValue(DriverId, VantagePro_DataFile, DataFile);
driverProfile.WriteValue(DriverId, VantagePro_SerialPort, PortName);
}
}
/// <summary>
/// Write the device configuration to the ASCOM Profile store
/// </summary>
internal void WriteProfile()
{
using (Profile driverProfile = new Profile()
{
DeviceType = "ObservingConditions"
})
{
driverProfile.WriteValue(DriverId, Profile_OpMode, OperationalMode.ToString());
driverProfile.WriteValue(DriverId, Profile_Tracing, Tracing.ToString());
driverProfile.WriteValue(DriverId, Profile_Interval, interval.TotalSeconds.ToString());
fetcher.WriteProfile();
}
}
internal FulltextIndexProvider(IndexProviderDescriptor descriptor, IndexDirectoryStructure.Factory directoryStructureFactory, FileSystemAbstraction fileSystem, Config config, TokenHolders tokenHolders, DirectoryFactory directoryFactory, OperationalMode operationalMode, JobScheduler scheduler, AuxiliaryTransactionStateManager auxiliaryTransactionStateManager, Log log) : base(descriptor, directoryStructureFactory)
{
this._fileSystem = fileSystem;
this._config = config;
this._tokenHolders = tokenHolders;
this._operationalMode = operationalMode;
this._auxiliaryTransactionStateManager = auxiliaryTransactionStateManager;
this._log = log;
_defaultAnalyzerName = config.Get(FulltextConfig.FulltextDefaultAnalyzer);
_defaultEventuallyConsistentSetting = Convert.ToString(config.Get(FulltextConfig.EventuallyConsistent));
_indexUpdateSink = new IndexUpdateSink(scheduler, config.Get(FulltextConfig.EventuallyConsistentIndexUpdateQueueMaxLength));
_openOnlineAccessors = new ConcurrentDictionary <StoreIndexDescriptor, FulltextIndexAccessor>();
_indexStorageFactory = BuildIndexStorageFactory(fileSystem, directoryFactory);
}
/// <summary>
/// Method to send an image to the client.
/// </summary>
/// <param name="image">The image to be sent.</param>
/// <param name="destLeft">The left bound of the frame.</param>
/// <param name="destTop">The top bound of the frame.</param>
/// <param name="frameId">The index of the sending frame.</param>
public static void SendImageToClient(Image image, ushort destLeft, ushort destTop, uint frameId)
{
OperationalMode opMode = OperationalMode.ImageMode;
EntropyAlgorithm enAlgorithm = EntropyAlgorithm.CLW_ENTROPY_RLGR1;
Site.Log.Add(LogEntryKind.Comment, "Sending Frame Marker Command (Begin) with frameID: {0}.", frameId);
rdpbcgrAdapter.SendFrameMarkerCommand(frameAction_Values.SURFACECMD_FRAMEACTION_BEGIN, frameId);
Site.Log.Add(LogEntryKind.Comment, "Sending encoded bitmap data to client. Operational Mode = {0}, Entropy Algorithm = {1}, destLeft = {2}, destTop = {3}.",
opMode, enAlgorithm, destLeft, destTop);
rdprfxAdapter.SendImageToClient(image, opMode, enAlgorithm, destLeft, destTop);
Site.Log.Add(LogEntryKind.Comment, "Sending Frame Marker Command (End) with frameID: {0}.", frameId);
rdpbcgrAdapter.SendFrameMarkerCommand(frameAction_Values.SURFACECMD_FRAMEACTION_END, frameId);
}
/// <summary>
/// Method to send TS_RFX_TILESET to client.
/// </summary>
/// <param name="opMode">Indicates the operational mode.</param>
/// <param name="entropy">Indicates the entropy algorithm.</param>
/// <param name="tileImages">The image array for tiles to be sent. The width and height must be less than or equals with 64.</param>
/// <param name="positions">A TILE_POSITION array indicating the positions of each tile images</param>
/// <param name="codecQuantVals">Quant values array</param>
/// <param name="quantIdxYs">Index array of Y component in Quant value array</param>
/// <param name="quantIdxCbs">Index array of Cb component in Quant value array</param>
/// <param name="quantIdxCrs">Index array of Cr component in Quant value array</param>
public void SendTsRfxTileSet(OperationalMode opMode, EntropyAlgorithm entropy, Image[] tileImages, TILE_POSITION[] positions,
TS_RFX_CODEC_QUANT[] codecQuantVals = null, byte[] quantIdxYs = null, byte[] quantIdxCbs = null, byte[] quantIdxCrs = null)
{
this.admEntropyAlgorithm = entropy;
this.admOperationMode = opMode;
TS_RFX_TILESET rfxTileSet = rdprfxServer.CreateTsRfxTileSet(opMode, entropy, tileImages, positions, codecQuantVals, quantIdxYs, quantIdxCbs, quantIdxCrs);
if (this.currentTestType == RdprfxNegativeType.TsRfxTileSet_InvalidIdx)
{
rfxTileSet.idx = 0x0001; //set to an invalid value other than 0x0000.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxTileSet_InvalidLt)
{
rfxTileSet.properties &= 0xFFFE; //set "lt" to an invalid value: 0x0.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxTileSet_InvalidCct)
{
rfxTileSet.properties &= 0xFFCF; //set "cct" to an invalid value: 0x0.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxTileSet_InvalidXft)
{
rfxTileSet.properties &= 0xFC3F; //set "xft" to an invalid value: 0x0.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxTileSet_InvalidQt)
{
rfxTileSet.properties &= 0x3FFF; //set "xft" to an invalid value: 0x0.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxTileSet_InvalidTileSize)
{
rfxTileSet.tileSize = 0x80; //set to an invalid value other than 0x40.
}
if (this.rdpbcgrAdapter.SimulatedScreen != null)
{
this.rdpbcgrAdapter.SimulatedScreen.SetRemoteFXTileSet(rfxTileSet, entropy);
}
AddToPendingList(rfxTileSet);
if (!CheckIfClientSupports(opMode, entropy))
{
Site.Log.Add(LogEntryKind.Debug, "The client Cap is not supported: OperationalMode = {0}, EntropyAlgorithm = {1}",
opMode.ToString(),
entropy.ToString());
}
}
protected override Task OnInitializedAsync()
{
BlazorWindowHelper.BlazorWindowHelper.Initialize();
BlazorWindowHelper.BWHJsInterop.SetOnOrOff(true);
BlazorWindowHelper.BlazorWindowHelper.OnScroll = OnScroll;
BlazorWindowHelper.BlazorWindowHelper.OnResize = OnScroll;
CurrentBackgroundImageURI = "";
CurrOperationalMode = OperationalMode.select;
OperationalModeHasChanged();
//buildDate = new DateTime(2000, 1, 1).AddDays(version.Build).AddSeconds(version.Revision * 2);
displayableVersion = $"{version}";
return(base.OnInitializedAsync());
}
/// <summary>
/// Copy from RDPRFX test suite code
/// </summary>
private void receiveAndLogClientRfxCapabilites()
{
uint maxRequestSize = 38055; // MS-RDPBCGR section 2.2.7.2.7
TS_RFX_ICAP[] clientRfxCaps;
this.TestSite.Log.Add(LogEntryKind.Comment, "Receive and check client capabilities...");
rdprfxAdapter.ReceiveAndCheckClientCapabilities(maxRequestSize, out clientRfxCaps);
if (clientRfxCaps != null)
{
foreach (TS_RFX_ICAP iCap in clientRfxCaps)
{
OperationalMode opMode = (OperationalMode)iCap.flags;
EntropyAlgorithm enAlg = (EntropyAlgorithm)iCap.entropyBits;
this.TestSite.Log.Add(LogEntryKind.Comment, "Client supports ({0}, {1}).", opMode, enAlg);
}
}
}
/// <summary>
/// Method to create TS_RFX_CONTEXT.
/// </summary>
/// <param name="isImageMode">Indicates the operational mode.</param>
/// <param name="entropy">Indicates the entropy algorithm.</param>
public TS_RFX_CONTEXT CreateTsRfxContext(OperationalMode opMode, EntropyAlgorithm entropy)
{
TS_RFX_CONTEXT rfxContext = new TS_RFX_CONTEXT();
rfxContext.CodecChannelT = new TS_RFX_CODEC_CHANNELT();
rfxContext.CodecChannelT.blockType = blockType_Value.WBT_CONTEXT;
rfxContext.CodecChannelT.blockLen = 13;
rfxContext.CodecChannelT.codecId = 0x01;
rfxContext.CodecChannelT.channelId = 0xFF;
rfxContext.ctxId = 0x00;
rfxContext.tileSize = 0x0040;
ushort flags = 0x0002;
if (opMode == OperationalMode.VideoMode)
{
flags = 0x0000;
}
ushort cct = 0x0001;
ushort xft = 0x0001;
ushort et = 0x0001;
if (entropy == EntropyAlgorithm.CLW_ENTROPY_RLGR3)
{
et = 0x0004;
}
ushort qt = 0x0001;
ushort r = 0x0000;
rfxContext.properties = 0x0000;
rfxContext.properties |= flags;
rfxContext.properties |= (ushort)(cct << 3);
rfxContext.properties |= (ushort)(xft << 5);
rfxContext.properties |= (ushort)(et << 9);
rfxContext.properties |= (ushort)(qt << 13);
rfxContext.properties |= (ushort)(r << 15);
return(rfxContext);
}
/// <summary>
/// Method to check if the input pair of the operation mode and entropy algorithm is supported by the client.
/// </summary>
/// <param name="opMode">The operation mode.</param>
/// <param name="entropy">The entropy algorithm.</param>
/// <returns></returns>
public bool CheckIfClientSupports(OperationalMode opMode, EntropyAlgorithm entropy)
{
TS_RFX_ICAP[] iCaps = this.client_RFX_Caps_Container.capsData.capsetsData[0].icapsData;
foreach (TS_RFX_ICAP icap in iCaps)
{
if ((icap.flags & (byte)OperationalMode.ImageMode) == (byte)0 &&
((byte)icap.entropyBits == (byte)entropy))
{
//OperationalMode.ImageMode is not set, both the image mode and the video mode of the codec are supported
return(true);
}
else if ((byte)icap.entropyBits == (byte)entropy)
{
//OperationalMode.ImageMode is set, only image mode is supported
if (opMode == OperationalMode.ImageMode)
{
return(true);
}
}
}
return(false);
}
public override Lifecycle NewInstance(KernelContext context, SchemaIndexHaIT.IndexProviderDependencies deps)
{
PageCache pageCache = deps.PageCache();
File databaseDirectory = context.Directory();
DefaultFileSystemAbstraction fs = FileSystemRule.get();
IndexProvider.Monitor monitor = IndexProvider.Monitor_Fields.EMPTY;
Config config = deps.Config();
OperationalMode operationalMode = context.DatabaseInfo().OperationalMode;
RecoveryCleanupWorkCollector recoveryCleanupWorkCollector = deps.RecoveryCleanupWorkCollector();
FusionIndexProvider fusionIndexProvider = NativeLuceneFusionIndexProviderFactory20.create(pageCache, databaseDirectory, fs, monitor, config, operationalMode, recoveryCleanupWorkCollector);
if (InjectLatchPredicate.test(deps.Db()))
{
ControlledIndexProvider provider = new ControlledIndexProvider(fusionIndexProvider);
PerDbIndexProvider[deps.Db()] = provider;
return(provider);
}
else
{
return(fusionIndexProvider);
}
}
// Set the operational mode.
// Mode = Standby, Query, Continuous
// Frequency = 1, 45, 10, 20 Hz
// Periodic reset = true/false
public void SetOperationalMode(OperationalMode mode, Frequency freq, Boolean periodicReset)
{
byte r = periodicReset ? (byte)(0x01 << 3) : (byte) 0;
byte f = (byte)((byte)freq << 5);
byte op = (byte)((byte)mode | r | f);
myI2Command[0] = I2CDevice.CreateWriteTransaction(new byte[] { (byte)Command.WriteEEPROM, (byte)EEPROMAddress.OperationalModeByte, op });
// Exécution de la transaction
BusI2C = new I2CDevice(ConfigHM6352); // Connexion virtuelle de l'objet HMC6352 au bus I2C
myBytesTransmitted = BusI2C.Execute(myI2Command, 100);
BusI2C.Dispose(); // Déconnexion virtuelle de l'objet HMC6352 du bus I2C
}
/// <summary>
/// Method to create TS_RFX_TILESET.
/// </summary>
/// <param name="opMode">Indicates the operational mode.</param>
/// <param name="entropy">Indicates the entropy algorithm.</param>
/// <param name="tileImages">An array of bitmaps in Image type for a tile. The width and heigth must be less than or equals with 64.</param>
/// <param name="positions">A TILE_POSITION array indicating the positions of each tile images</param>
/// <param name="codecQuantVals">Quant values array</param>
/// <param name="quantIdxYs">Index array of Y component in Quant value array</param>
/// <param name="quantIdxCbs">Index array of Cb component in Quant value array</param>
/// <param name="quantIdxCrs">Index array of Cr component in Quant value array</param>
/// <returns></returns>
public TS_RFX_TILESET CreateTsRfxTileSet(
OperationalMode opMode,
EntropyAlgorithm entropy,
Image[] tileImages,
TILE_POSITION[] positions,
TS_RFX_CODEC_QUANT[] codecQuantVals = null,
byte[] quantIdxYs = null,
byte[] quantIdxCbs = null,
byte[] quantIdxCrs = null
)
{
if (codecQuantVals == null)
{
codecQuantVals = new TS_RFX_CODEC_QUANT[1];
codecQuantVals[0] = codecQuant;
}
TS_RFX_TILESET rfxTileSet = new TS_RFX_TILESET();
rfxTileSet.CodecChannelT = new TS_RFX_CODEC_CHANNELT();
rfxTileSet.CodecChannelT.blockType = blockType_Value.WBT_EXTENSION;
rfxTileSet.CodecChannelT.blockLen = 22 + 5;
rfxTileSet.CodecChannelT.codecId = 0x01;
rfxTileSet.CodecChannelT.channelId = 0x00;
rfxTileSet.subtype = 0xCAC2;
rfxTileSet.idx = 0x0000;
ushort lt = 0x0001;
ushort flags = 0x0002;
if (opMode == OperationalMode.VideoMode) flags = 0x0000;
ushort cct = 0x0001;
ushort xft = 0x0001;
ushort et = 0x0001;
if (entropy == EntropyAlgorithm.CLW_ENTROPY_RLGR3) et = 0x0004;
ushort qt = 0x0001;
rfxTileSet.properties = lt;
rfxTileSet.properties |= (ushort)(flags << 1);
rfxTileSet.properties |= (ushort)(cct << 4);
rfxTileSet.properties |= (ushort)(xft << 6);
rfxTileSet.properties |= (ushort)(et << 10);
rfxTileSet.properties |= (ushort)(qt << 14);
rfxTileSet.numQuant = (byte)codecQuantVals.Length;
rfxTileSet.tileSize = RdprfxServer.TileSize;
rfxTileSet.numTiles = 1;
rfxTileSet.quantVals = codecQuantVals;
byte[] yData, cbData, crData;
rfxTileSet.tiles = new TS_RFX_TILE[tileImages.Length];
rfxTileSet.numTiles = (ushort) rfxTileSet.tiles.Length;
for (int i = 0; i < tileImages.Length; i++)
{
byte quantIdxY = quantIdxYs == null ? (byte)0 : (quantIdxYs.Length > i ? quantIdxYs[i] : (byte)0);
byte quantIdxCb = quantIdxCbs == null ? (byte)0 : (quantIdxCbs.Length > i ? quantIdxCbs[i] : (byte)0);
byte quantIdxCr = quantIdxCrs == null ? (byte)0 : (quantIdxCrs.Length > i ? quantIdxCrs[i] : (byte)0);
RemoteFXCodecContext encodingContext = new RemoteFXCodecContext(codecQuantVals, quantIdxY, quantIdxCb, quantIdxCr, entropy);
RemoteFXEncoder.EncodeTile(tileImages[i], 0, 0, encodingContext);
yData = encodingContext.YData;
cbData = encodingContext.CbData;
crData = encodingContext.CrData;
rfxTileSet.tiles[i].BlockT.blockType = blockType_Value.CBT_TILE;
rfxTileSet.tiles[i].BlockT.blockLen = (uint)(19 + yData.Length + cbData.Length + crData.Length);
rfxTileSet.tiles[i].quantIdxY = quantIdxY;
rfxTileSet.tiles[i].quantIdxCb = quantIdxCb;
rfxTileSet.tiles[i].quantIdxCr = quantIdxCr;
rfxTileSet.tiles[i].xIdx = positions[i].xIdx;
rfxTileSet.tiles[i].yIdx = positions[i].yIdx;
rfxTileSet.tiles[i].YLen = (ushort)yData.Length;
rfxTileSet.tiles[i].CbLen = (ushort)cbData.Length;
rfxTileSet.tiles[i].CrLen = (ushort)crData.Length;
rfxTileSet.tiles[i].YData = yData;
rfxTileSet.tiles[i].CbData = cbData;
rfxTileSet.tiles[i].CrData = crData;
rfxTileSet.tilesDataSize += rfxTileSet.tiles[i].BlockT.blockLen;
rfxTileSet.CodecChannelT.blockLen = (uint)(22 + 5 * rfxTileSet.numQuant + rfxTileSet.tilesDataSize);
}
return rfxTileSet;
}
private void NegtiveTest_DuplicatedTile(OperationalMode mode)
{
#region Test Description
/*
Step 1: [RDPBCGR] establishing the connection.
Step 2: [RDPBCGR] send Frame Maker Command (Begin) to SUT.
Step 3: [RDPRFX] Send Encode Header Messages to SUT.
Step 4: [RDPRFX] Send one frame of Encode Data Messages (encoded with RLGR1) to SUT, the TS_RFX_REGION structure contains rectangular which contains a duplicated tile.
Step 5: [RDPRFX] Expect the client terminates the RDP connection.
*/
#endregion
#region Test Sequence
//Start RDP listening.
this.TestSite.Log.Add(LogEntryKind.Comment, "Starting RDP listening.");
this.rdpbcgrAdapter.StartRDPListening(transportProtocol);
#region Trigger client to connect
//Trigger client to connect.
this.TestSite.Log.Add(LogEntryKind.Comment, "Triggering SUT to initiate a RDP connection to server.");
triggerClientRDPConnect(transportProtocol, true);
#endregion
#region RDPBCGR Connection
//Waiting for the transport level connection request.
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting the transport layer connection request.");
this.rdpbcgrAdapter.ExpectTransportConnection(RDPSessionType.Normal);
//Set Server Capability with RomoteFX codec supported.
this.TestSite.Log.Add(LogEntryKind.Comment, "Setting Server Capability.");
setServerCapabilitiesWithRemoteFxSupported();
//Waiting for the RDP connection sequence.
this.TestSite.Log.Add(LogEntryKind.Comment, "Establishing RDP connection.");
this.rdpbcgrAdapter.EstablishRDPConnection(selectedProtocol, enMethod, enLevel, true, false, rdpServerVersion);
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Server Save Session Info PDU to SUT to notify user has logged on.");
this.rdpbcgrAdapter.ServerSaveSessionInfo(LogonNotificationType.UserLoggedOn, ErrorNotificationType_Values.LOGON_FAILED_OTHER);
#endregion
//Initial the RDPRFX adapter context.
rdprfxAdapter.Accept(this.rdpbcgrAdapter.ServerStack, this.rdpbcgrAdapter.SessionContext);
receiveAndLogClientRfxCapabilites();
uint frameId = 0; //The index of the sending frame.
OperationalMode opMode = mode;
EntropyAlgorithm enAlgorithm = EntropyAlgorithm.CLW_ENTROPY_RLGR1;
ushort destLeft = 0; //the left bound of the frame.
ushort destTop = 0; //the top bound of the frame.
//Check if the above setting is supported by client.
if (!this.rdprfxAdapter.CheckIfClientSupports(opMode, enAlgorithm))
{
this.TestSite.Log.Add(LogEntryKind.Comment, "the input pair of Operational Mode ({0}) / Entropy Algorithm ({1}) is not supported by client, so stop running this test case.", opMode, enAlgorithm);
return;
}
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Frame Marker Command (Begin) with frameID: {0}.", frameId);
rdpbcgrAdapter.SendFrameMarkerCommand(frameAction_Values.SURFACECMD_FRAMEACTION_BEGIN, frameId);
this.TestSite.Log.Add(LogEntryKind.Comment, "Start to send encoded bitmap data to client. Operational Mode = {0}, Entropy Algorithm = {1}, destLeft = {2}, destTop = {3}.",
opMode, enAlgorithm, destLeft, destTop);
this.TestSite.Log.Add(LogEntryKind.Comment, "Create rectangles list, this rectangle list is used for TS_RFX_REGION structure to clip the bitmap.");
Rectangle clipRect1 = new Rectangle(0, 0, RgbTile.TileSize * 2, RgbTile.TileSize * 2);
Rectangle[] rects = new Rectangle[] { clipRect1 };
rdprfxAdapter.SendTsRfxSync();
rdprfxAdapter.SendTsRfxCodecVersions();
rdprfxAdapter.SendTsRfxChannels(RgbTile.TileSize * 2, RgbTile.TileSize * 2);
rdprfxAdapter.SendTsRfxContext(opMode, enAlgorithm);
var bitmapBlue = new Bitmap(RgbTile.TileSize, RgbTile.TileSize);
Graphics graphics = Graphics.FromImage(bitmapBlue);
graphics.FillRectangle(Brushes.Blue, new Rectangle(0, 0, RgbTile.TileSize, RgbTile.TileSize));
var bitmapRed = new Bitmap(RgbTile.TileSize, RgbTile.TileSize);
graphics = Graphics.FromImage(bitmapRed);
graphics.FillRectangle(Brushes.Red, new Rectangle(0, 0, RgbTile.TileSize, RgbTile.TileSize));
rdprfxAdapter.SendTsRfxFrameBegin(0);
rdprfxAdapter.SendTsRfxRegion(rects);
TILE_POSITION[] positions = new TILE_POSITION[5]{
new TILE_POSITION{ xIdx = 1, yIdx = 1 },
new TILE_POSITION{ xIdx = 0, yIdx = 0 },
new TILE_POSITION{ xIdx = 1, yIdx = 0 },
new TILE_POSITION{ xIdx = 0, yIdx = 1 },
new TILE_POSITION{ xIdx = 1, yIdx = 1 },
};
rdprfxAdapter.SendTsRfxTileSet(
opMode,
enAlgorithm,
new Image[] { bitmapRed, bitmapBlue, bitmapBlue, bitmapBlue, bitmapBlue },
positions);
rdprfxAdapter.SendTsRfxFrameEnd();
rdprfxAdapter.FlushEncodedData(destLeft, destTop, RgbTile.TileSize * 2, RgbTile.TileSize * 2);
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting the client terminates the RDP connection.");
bool bDisconnected = rdpbcgrAdapter.WaitForDisconnection(waitTime);
this.TestSite.Assert.IsTrue(bDisconnected, "Client is expected to drop the connection if received duplicated tiles in Video Mode when Image Mode is in effect.");
#endregion
}
private void SendOutOfRects(OperationalMode mode)
{
#region Test Description
/*
Step 1: [RDPBCGR] establishing the connection.
Step 2: [RDPBCGR] send Frame Maker Command (Begin) to SUT.
Step 3: [RDPRFX] Send Encode Header Messages to SUT.
Step 4: [RDPRFX] Send one frame of Encode Data Messages (encoded with RLGR1) to SUT, when some tiles are out of the rectangle in TS_RFX_REGION.
Step 5: [RDPBCGR] send Frame Maker Command (End) to SUT.
Step 6: [RDPRFX] Expect SUT sends a TS_FRAME_ACKNOWLEDGE_PDU.
*/
#endregion
#region Test Sequence
//Start RDP listening.
this.TestSite.Log.Add(LogEntryKind.Comment, "Starting RDP listening.");
this.rdpbcgrAdapter.StartRDPListening(transportProtocol);
#region Trigger client to connect
//Trigger client to connect.
this.TestSite.Log.Add(LogEntryKind.Comment, "Triggering SUT to initiate a RDP connection to server.");
triggerClientRDPConnect(transportProtocol, true);
#endregion
#region RDPBCGR Connection
//Waiting for the transport level connection request.
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting the transport layer connection request.");
this.rdpbcgrAdapter.ExpectTransportConnection(RDPSessionType.Normal);
//Set Server Capability with RomoteFX codec supported.
this.TestSite.Log.Add(LogEntryKind.Comment, "Setting Server Capability.");
setServerCapabilitiesWithRemoteFxSupported();
//Waiting for the RDP connection sequence.
this.TestSite.Log.Add(LogEntryKind.Comment, "Establishing RDP connection.");
this.rdpbcgrAdapter.EstablishRDPConnection(selectedProtocol, enMethod, enLevel, true, false, rdpServerVersion);
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Server Save Session Info PDU to SUT to notify user has logged on.");
this.rdpbcgrAdapter.ServerSaveSessionInfo(LogonNotificationType.UserLoggedOn, ErrorNotificationType_Values.LOGON_FAILED_OTHER);
#endregion
//Initial the RDPRFX adapter context.
rdprfxAdapter.Accept(this.rdpbcgrAdapter.ServerStack, this.rdpbcgrAdapter.SessionContext);
receiveAndLogClientRfxCapabilites();
uint frameId = 0; //The index of the sending frame.
OperationalMode opMode = mode;
EntropyAlgorithm enAlgorithm = EntropyAlgorithm.CLW_ENTROPY_RLGR1;
ushort destLeft = 0; //the left bound of the frame.
ushort destTop = 0; //the top bound of the frame.
//Check if the above setting is supported by client.
if (!this.rdprfxAdapter.CheckIfClientSupports(opMode, enAlgorithm))
{
this.TestSite.Log.Add(LogEntryKind.Comment, "the input pair of Operational Mode ({0}) / Entropy Algorithm ({1}) is not supported by client, so stop running this test case.", opMode, enAlgorithm);
return;
}
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Frame Marker Command (Begin) with frameID: {0}.", frameId);
rdpbcgrAdapter.SendFrameMarkerCommand(frameAction_Values.SURFACECMD_FRAMEACTION_BEGIN, frameId);
this.TestSite.Log.Add(LogEntryKind.Comment, "Start to send encoded bitmap data to client. Operational Mode = {0}, Entropy Algorithm = {1}, destLeft = {2}, destTop = {3}.",
opMode, enAlgorithm, destLeft, destTop);
this.TestSite.Log.Add(LogEntryKind.Comment, "Create rectangles whose height is TileSize/2, this rectangle is used for TS_RFX_REGION structure to clip the bitmap.");
Rectangle clipRect = new Rectangle(64, 64, RgbTile.TileSize, RgbTile.TileSize);
Rectangle[] rects = new Rectangle[] { clipRect };
rdprfxAdapter.SendTsRfxSync();
rdprfxAdapter.SendTsRfxCodecVersions();
rdprfxAdapter.SendTsRfxChannels(RgbTile.TileSize * 2, RgbTile.TileSize * 2);
rdprfxAdapter.SendTsRfxContext(opMode, enAlgorithm);
rdprfxAdapter.SendTsRfxFrameBegin(0);
rdprfxAdapter.SendTsRfxRegion(rects);
TILE_POSITION[] positions = new TILE_POSITION[4]{
new TILE_POSITION{ xIdx = 0, yIdx = 0 },
new TILE_POSITION{ xIdx = 0, yIdx = 1 },
new TILE_POSITION{ xIdx = 1, yIdx = 0 },
new TILE_POSITION{ xIdx = 1, yIdx = 1 }
};
rdprfxAdapter.SendTsRfxTileSet(
opMode,
enAlgorithm,
new Image[] { image_64X64, image_64X64, image_64X64, image_64X64 },
positions);
rdprfxAdapter.SendTsRfxFrameEnd();
rdprfxAdapter.FlushEncodedData(destLeft, destTop, RgbTile.TileSize * 2, RgbTile.TileSize * 2);
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Frame Marker Command (End) with frameID: {0}.", frameId);
rdpbcgrAdapter.SendFrameMarkerCommand(frameAction_Values.SURFACECMD_FRAMEACTION_END, frameId);
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting TS_FRAME_ACKNOWLEDGE_PDU.");
rdprfxAdapter.ExpectTsFrameAcknowledgePdu(frameId, waitTime);
this.TestSite.Log.Add(LogEntryKind.Comment, "Verify output on SUT Display if the verifySUTDisplay entry in PTF config is true.");
Rectangle compareRect = new Rectangle(destLeft, destTop, RgbTile.TileSize * 2, RgbTile.TileSize * 2);
this.VerifySUTDisplay(true, compareRect);
#endregion
}
public void Rdprfx_HeaderMessage_NegativeTest_UnspecifiedMessage()
{
#region Test Description
/*
Step 1: [RDPBCGR] establish the RDP connection.
Step 2: [RDPRFX] send one unspecified message to client.
Step 3: [RDPRFX] expect SUT terminate the RDP connectioin.
*/
#endregion
#region Test Sequence
//Start RDP listening.
this.TestSite.Log.Add(LogEntryKind.Comment, "Starting RDP listening.");
this.rdpbcgrAdapter.StartRDPListening(transportProtocol);
#region Trigger client to connect
//Trigger client to connect.
this.TestSite.Log.Add(LogEntryKind.Comment, "Triggering SUT to initiate a RDP connection to server.");
triggerClientRDPConnect(transportProtocol);
#endregion
#region RDPBCGR Connection
//Waiting for the transport level connection request.
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting the transport layer connection request.");
this.rdpbcgrAdapter.ExpectTransportConnection(RDPSessionType.Normal);
//Set Server Capability with RomoteFX codec supported.
this.TestSite.Log.Add(LogEntryKind.Comment, "Setting Server Capability.");
setServerCapabilitiesWithRemoteFxSupported();
//Waiting for the RDP connection sequence.
this.TestSite.Log.Add(LogEntryKind.Comment, "Establishing RDP connection.");
this.rdpbcgrAdapter.EstablishRDPConnection(selectedProtocol, enMethod, enLevel, true, false, rdpServerVersion);
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Server Save Session Info PDU to SUT to notify user has logged on.");
this.rdpbcgrAdapter.ServerSaveSessionInfo(LogonNotificationType.UserLoggedOn, ErrorNotificationType_Values.LOGON_FAILED_OTHER);
#endregion
//Initial the RDPRFX adapter context.
rdprfxAdapter.Accept(this.rdpbcgrAdapter.ServerStack, this.rdpbcgrAdapter.SessionContext);
#region Fill parameters
TS_RFX_ICAP[] clientSupportedCaps;
rdprfxAdapter.ReceiveAndCheckClientCapabilities(maxRequestSize, out clientSupportedCaps);
OperationalMode opMode = OperationalMode.ImageMode;
EntropyAlgorithm enAlgorithm = EntropyAlgorithm.CLW_ENTROPY_RLGR3;
ushort destLeft = 0; //the left bound of the frame.
ushort destTop = 0; //the top bound of the frame.
//Set OperationalMode/EntropyAlgorithm to valid pair.
if (clientSupportedCaps != null)
{
opMode = (OperationalMode)clientSupportedCaps[0].flags;
enAlgorithm = (EntropyAlgorithm)clientSupportedCaps[0].entropyBits;
}
#endregion
this.TestSite.Log.Add(LogEntryKind.Comment, "Set the test type to {0}.", RdprfxNegativeType.UnspecifiedBlockType);
rdprfxAdapter.SetTestType(RdprfxNegativeType.UnspecifiedBlockType);
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Encode Header/Data Messages to client.");
rdprfxAdapter.SendImageToClient(image_64X64, opMode, enAlgorithm, destLeft, destTop);
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting the client terminates the RDP connection.");
bool bDisconnected = rdpbcgrAdapter.WaitForDisconnection(waitTime);
this.TestSite.Assert.IsTrue(bDisconnected, "Client is expected to drop the connection when received an invalid message.");
#endregion
}
/// <summary>
/// Method to check if the input pair of the operation mode and entropy algorithm is supported by the client.
/// </summary>
/// <param name="opMode">The operation mode.</param>
/// <param name="entropy">The entropy algorithm.</param>
/// <returns></returns>
public bool CheckIfClientSupports(OperationalMode opMode, EntropyAlgorithm entropy)
{
TS_RFX_ICAP[] iCaps = this.client_RFX_Caps_Container.capsData.capsetsData[0].icapsData;
foreach (TS_RFX_ICAP icap in iCaps)
{
if ((icap.flags & (byte)OperationalMode.ImageMode) == (byte)0 &&
((byte)icap.entropyBits == (byte)entropy))
{
//OperationalMode.ImageMode is not set, both the image mode and the video mode of the codec are supported
return true;
}
else if ((byte)icap.entropyBits == (byte)entropy)
{
//OperationalMode.ImageMode is set, only image mode is supported
if (opMode == OperationalMode.ImageMode)
return true;
}
}
return false;
}
/// <summary>
/// Method to send one frame of encoded data message to client.
/// </summary>
/// <param name="image">The image to be sent.</param>
/// <param name="opMode">Indicates the operational mode.</param>
/// <param name="entropy">Indicates the entropy algorithm.</param>
/// <param name="destLeft">Left bound of the frame.</param>
/// <param name="destTop">Left bound of the frame.</param>
public void SendImageToClient(System.Drawing.Image image, OperationalMode opMode, EntropyAlgorithm entropy, ushort destLeft, ushort destTop)
{
if (image == null)
{
Site.Log.Add(LogEntryKind.Debug, "[In iRdprfxAdapter.SendImageToClient Method] The image to be send is null.");
return;
}
TileImage[] tileImageArr = RdprfxTileUtils.SplitToTileImage(image, RdprfxServer.TileSize, RdprfxServer.TileSize);
for (int idx = 0; idx < tileImageArr.Length; idx++)
{
if (idx == 0 || opMode == OperationalMode.ImageMode)
{
SendTsRfxSync();
SendTsRfxCodecVersions();
SendTsRfxChannels();
SendTsRfxContext(opMode, entropy);
}
SendTsRfxFrameBegin((uint)idx);
SendTsRfxRegion();
SendTsRfxTileSet(opMode, entropy, tileImageArr[idx].image);
SendTsRfxFrameEnd();
FlushEncodedData((ushort)(destLeft + tileImageArr[idx].x), (ushort)(destTop + tileImageArr[idx].y));
if (currentTestType != RdprfxNegativeType.None)
{
// Only send one message if it is in a negative test case.
break;
}
}
}
/// <summary>
/// Method to send TS_RFX_TILESET to client.
/// </summary>
/// <param name="opMode">Indicates the operational mode.</param>
/// <param name="entropy">Indicates the entropy algorithm.</param>
/// <param name="tileImages">The image array for tiles to be sent. The width and height must be less than or equals with 64.</param>
/// <param name="positions">A TILE_POSITION array indicating the positions of each tile images</param>
/// <param name="codecQuantVals">Quant values array</param>
/// <param name="quantIdxYs">Index array of Y component in Quant value array</param>
/// <param name="quantIdxCbs">Index array of Cb component in Quant value array</param>
/// <param name="quantIdxCrs">Index array of Cr component in Quant value array</param>
public void SendTsRfxTileSet(OperationalMode opMode, EntropyAlgorithm entropy, Image[] tileImages, TILE_POSITION[] positions,
TS_RFX_CODEC_QUANT[] codecQuantVals = null, byte[] quantIdxYs = null, byte[] quantIdxCbs = null, byte[] quantIdxCrs = null)
{
this.admEntropyAlgorithm = entropy;
this.admOperationMode = opMode;
TS_RFX_TILESET rfxTileSet = rdprfxServer.CreateTsRfxTileSet(opMode, entropy, tileImages, positions, codecQuantVals, quantIdxYs, quantIdxCbs, quantIdxCrs);
if (this.currentTestType == RdprfxNegativeType.TsRfxTileSet_InvalidIdx)
{
rfxTileSet.idx = 0x0001; //set to an invalid value other than 0x0000.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxTileSet_InvalidLt)
{
rfxTileSet.properties &= 0xFFFE; //set "lt" to an invalid value: 0x0.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxTileSet_InvalidCct)
{
rfxTileSet.properties &= 0xFFCF; //set "cct" to an invalid value: 0x0.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxTileSet_InvalidXft)
{
rfxTileSet.properties &= 0xFC3F; //set "xft" to an invalid value: 0x0.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxTileSet_InvalidQt)
{
rfxTileSet.properties &= 0x3FFF; //set "xft" to an invalid value: 0x0.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxTileSet_InvalidTileSize)
{
rfxTileSet.tileSize = 0x80; //set to an invalid value other than 0x40.
}
if (this.rdpbcgrAdapter.SimulatedScreen != null)
{
this.rdpbcgrAdapter.SimulatedScreen.SetRemoteFXTileSet(rfxTileSet, entropy);
}
AddToPendingList(rfxTileSet);
if (!CheckIfClientSupports(opMode, entropy))
{
Site.Log.Add(LogEntryKind.Debug, "The client Cap is not supported: OperationalMode = {0}, EntropyAlgorithm = {1}",
opMode.ToString(),
entropy.ToString());
}
}
public SbtResult SetOperationalMode(OperationalMode operationalMode)
{
return((SbtResult)global::ApiDefinitions.ZebraMessaging.UInt32_objc_msgSend_UInt32(this.Handle, Selector.GetHandle("sbtSetOperationalMode:"), (UInt32)operationalMode));
}
/// <summary>
/// Method to send TS_RFX_CONTEXT to client.
/// </summary>
/// <param name="isImageMode">Indicates the operational mode.</param>
/// <param name="entropy">Indicates the entropy algorithm.</param>
public void SendTsRfxContext(OperationalMode opMode, EntropyAlgorithm entropy)
{
this.admEntropyAlgorithm = entropy;
this.admOperationMode = opMode;
TS_RFX_CONTEXT rfxContext = rdprfxServer.CreateTsRfxContext(opMode, entropy);
if (this.currentTestType == RdprfxNegativeType.TsRfxContext_InvalidCtxId)
{
rfxContext.ctxId = 0x01; //set to an invalid value other than 0x00.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxContext_InvalidTileSize)
{
rfxContext.tileSize = 0x0080; //set to an invalid value other than 0x0040.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxContext_InvalidCct)
{
rfxContext.properties &= 0xFFF7; //set "cct" to an invalid value: 0x0.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxContext_InvalidXft)
{
rfxContext.properties &= 0xFE1F; //set "xft" to an invalid value: 0x0.
}
else if (this.currentTestType == RdprfxNegativeType.TsRfxContext_InvalidQt)
{
rfxContext.properties &= 0x9FFF; //set "qt" to an invalid value: 0x0.
}
AddToPendingList(rfxContext);
}
/// <summary>
/// Pack a Rdprfx message for a tile image.
/// </summary>
/// <param name="index"> Frame index in frame begin block.</param>
/// <param name="opMode"> Indicate Operational Mode.</param>
/// <param name="entropy"> Indicate Entropy Algorithm.</param>
/// <param name="tileImage"> The image to be encoded as RFX codec.</param>
/// <return> A byte array of image encoded as RFX codec.</return>
private byte[] PackRfxTileImage(uint index, OperationalMode opMode, EntropyAlgorithm entropy, System.Drawing.Image tileImage)
{
lock (syncLocker)
{
pendingRfxBuffer.Clear();
}
if (index == 0 || opMode == OperationalMode.ImageMode)
{
TS_RFX_SYNC rfxSync = rdprfxServer.CreateTsRfxSync();
AddToPendingList(rfxSync);
TS_RFX_CODEC_VERSIONS rfxVersions = rdprfxServer.CreateTsRfxCodecVersions();
AddToPendingList(rfxVersions);
TS_RFX_CHANNELS rfxChannels = rdprfxServer.CreateTsRfxChannels();
AddToPendingList(rfxChannels);
TS_RFX_CONTEXT rfxContext = rdprfxServer.CreateTsRfxContext(opMode, entropy);
AddToPendingList(rfxContext);
}
TS_RFX_FRAME_BEGIN rfxBegin = rdprfxServer.CreateTsRfxFrameBegin(index);
AddToPendingList(rfxBegin);
TS_RFX_REGION rfxRegion = rdprfxServer.CreateTsRfxRegion();
AddToPendingList(rfxRegion);
TS_RFX_TILESET rfxTileSet = rdprfxServer.CreateTsRfxTileSet(opMode, entropy, tileImage);
AddToPendingList(rfxTileSet);
TS_RFX_FRAME_END rfxEnd = rdprfxServer.CreateTsRfxFrameEnd();
AddToPendingList(rfxEnd);
if (this.bcgrAdapter.SimulatedScreen != null)
{
this.bcgrAdapter.SimulatedScreen.SetRemoteFXRegion(rfxRegion);
this.bcgrAdapter.SimulatedScreen.SetRemoteFXTileSet(rfxTileSet, entropy);
}
lock (syncLocker)
{
return pendingRfxBuffer.ToArray();
}
}
public void Rdprfx_ImageMode_PositiveTest_MultiQuantVals()
{
#region Test Description
/*
* Step 1: [RDPBCGR] establishing the connection.
* Step 2: [RDPBCGR] send Frame Maker Command (Begin) to SUT.
* Step 3: [RDPRFX] Send Encode Header Messages to SUT.
* Step 4: [RDPRFX] Send one frame of Encode Data Messages (encoded with RLGR1) to SUT, each component use different quantization value.
* Step 5: [RDPBCGR] send Frame Maker Command (End) to SUT.
* Step 6: [RDPRFX] Expect SUT sends a TS_FRAME_ACKNOWLEDGE_PDU.
*/
#endregion
#region Test Sequence
//Start RDP listening.
this.TestSite.Log.Add(LogEntryKind.Comment, "Starting RDP listening.");
this.rdpbcgrAdapter.StartRDPListening(transportProtocol);
#region Trigger client to connect
//Trigger client to connect.
this.TestSite.Log.Add(LogEntryKind.Comment, "Triggering SUT to initiate a RDP connection to server.");
triggerClientRDPConnect(transportProtocol, true);
#endregion
#region RDPBCGR Connection
//Waiting for the transport level connection request.
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting the transport layer connection request.");
this.rdpbcgrAdapter.ExpectTransportConnection(RDPSessionType.Normal);
//Set Server Capability with RomoteFX codec supported.
this.TestSite.Log.Add(LogEntryKind.Comment, "Setting Server Capability.");
setServerCapabilitiesWithRemoteFxSupported();
//Waiting for the RDP connection sequence.
this.TestSite.Log.Add(LogEntryKind.Comment, "Establishing RDP connection.");
this.rdpbcgrAdapter.EstablishRDPConnection(selectedProtocol, enMethod, enLevel, true, false, rdpServerVersion);
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Server Save Session Info PDU to SUT to notify user has logged on.");
this.rdpbcgrAdapter.ServerSaveSessionInfo(LogonNotificationType.UserLoggedOn, ErrorNotificationType_Values.LOGON_FAILED_OTHER);
#endregion
//Initial the RDPRFX adapter context.
rdprfxAdapter.Accept(this.rdpbcgrAdapter.ServerStack, this.rdpbcgrAdapter.SessionContext);
receiveAndLogClientRfxCapabilites();
uint frameId = 0; //The index of the sending frame.
OperationalMode opMode = OperationalMode.ImageMode;
EntropyAlgorithm enAlgorithm = EntropyAlgorithm.CLW_ENTROPY_RLGR1;
ushort destLeft = 64; //the left bound of the frame.
ushort destTop = 64; //the top bound of the frame.
//Check if the above setting is supported by the client.
if (!this.rdprfxAdapter.CheckIfClientSupports(opMode, enAlgorithm))
{
this.TestSite.Log.Add(LogEntryKind.Comment, "the input pair of Operational Mode ({0}) / Entropy Algorithm ({1}) is not supported by the client, so stop running this test case.", opMode, enAlgorithm);
return;
}
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Frame Marker Command (Begin) with frameID: {0}.", frameId);
rdpbcgrAdapter.SendFrameMarkerCommand(frameAction_Values.SURFACECMD_FRAMEACTION_BEGIN, frameId);
this.TestSite.Log.Add(LogEntryKind.Comment, "Start to send encoded bitmap data to client. Operational Mode = {0}, Entropy Algorithm = {1}, destLeft = {2}, destTop = {3}.",
opMode, enAlgorithm, destLeft, destTop);
this.TestSite.Log.Add(LogEntryKind.Comment, "Generate Quantization value, each component has different quant index.");
TS_RFX_CODEC_QUANT[] quantVals = this.GenerateCodecQuantVals();
byte quantIdxY = 0;
byte quantIdxCb = 1;
byte quantIdxCr = 2;
TileImage[] tileImageArr = RdprfxTileUtils.SplitToTileImage(image_64X64, RdprfxServer.TileSize, RdprfxServer.TileSize);
for (int idx = 0; idx < tileImageArr.Length; idx++)
{
if (idx == 0)
{
rdprfxAdapter.SendTsRfxSync();
rdprfxAdapter.SendTsRfxCodecVersions();
rdprfxAdapter.SendTsRfxChannels();
rdprfxAdapter.SendTsRfxContext(opMode, enAlgorithm);
}
rdprfxAdapter.SendTsRfxFrameBegin((uint)idx);
rdprfxAdapter.SendTsRfxRegion();
rdprfxAdapter.SendTsRfxTileSet(opMode, enAlgorithm, tileImageArr[idx].image, quantVals, quantIdxY, quantIdxCb, quantIdxCr);
rdprfxAdapter.SendTsRfxFrameEnd();
rdprfxAdapter.FlushEncodedData((ushort)(destLeft + tileImageArr[idx].x), (ushort)(destTop + tileImageArr[idx].y));
}
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Frame Marker Command (End) with frameID: {0}.", frameId);
rdpbcgrAdapter.SendFrameMarkerCommand(frameAction_Values.SURFACECMD_FRAMEACTION_END, frameId);
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting TS_FRAME_ACKNOWLEDGE_PDU.");
rdprfxAdapter.ExpectTsFrameAcknowledgePdu(frameId, waitTime);
this.TestSite.Log.Add(LogEntryKind.Comment, "Verify output on SUT Display if the verifySUTDisplay entry in PTF config is true.");
Rectangle compareRect = new Rectangle(destLeft, destTop, image_64X64.Width, image_64X64.Height);
this.VerifySUTDisplay(true, compareRect);
#endregion
}
/// <summary>
/// Method to create TS_RFX_TILESET.
/// </summary>
/// <param name="isImageMode">Indicates the operational mode.</param>
/// <param name="entropy">Indicates the entropy algorithm.</param>
/// <param name="tileImage">A RgbTile. The width and heigth must be less than or equals with 64.</param>
public TS_RFX_TILESET CreateTsRfxTileSet(OperationalMode opMode, EntropyAlgorithm entropy, RgbTile tileImage)
{
TS_RFX_TILESET rfxTileSet = new TS_RFX_TILESET();
rfxTileSet.CodecChannelT = new TS_RFX_CODEC_CHANNELT();
rfxTileSet.CodecChannelT.blockType = blockType_Value.WBT_EXTENSION;
rfxTileSet.CodecChannelT.blockLen = 22 + 5;
rfxTileSet.CodecChannelT.codecId = 0x01;
rfxTileSet.CodecChannelT.channelId = 0x00;
rfxTileSet.subtype = 0xCAC2;
rfxTileSet.idx = 0x0000;
ushort lt = 0x0001;
ushort flags = 0x0002;
if (opMode == OperationalMode.VideoMode) flags = 0x0000;
ushort cct = 0x0001;
ushort xft = 0x0001;
ushort et = 0x0001;
if (entropy == EntropyAlgorithm.CLW_ENTROPY_RLGR3) et = 0x0004;
ushort qt = 0x0001;
rfxTileSet.properties = lt;
rfxTileSet.properties |= (ushort)(flags << 1);
rfxTileSet.properties |= (ushort)(cct << 4);
rfxTileSet.properties |= (ushort)(xft << 6);
rfxTileSet.properties |= (ushort)(et << 10);
rfxTileSet.properties |= (ushort)(qt << 14);
rfxTileSet.numQuant = 1;
rfxTileSet.tileSize = RdprfxServer.TileSize;
rfxTileSet.numTiles = 1;
rfxTileSet.quantVals = new TS_RFX_CODEC_QUANT[1];
rfxTileSet.quantVals[0] = codecQuant;
byte[] yData, cbData, crData;
RemoteFXCodecContext encodingContext = new RemoteFXCodecContext(codecQuant, entropy);
RemoteFXEncoder.EncodeTile(tileImage, 0, 0, encodingContext);
yData = encodingContext.YData;
cbData = encodingContext.CbData;
crData = encodingContext.CrData;
rfxTileSet.tiles = new TS_RFX_TILE[1];
rfxTileSet.tiles[0].BlockT.blockType = blockType_Value.CBT_TILE;
rfxTileSet.tiles[0].BlockT.blockLen = (uint)(19 + yData.Length + cbData.Length + crData.Length);
rfxTileSet.tiles[0].quantIdxY = 0;
rfxTileSet.tiles[0].quantIdxCb = 0;
rfxTileSet.tiles[0].quantIdxCr = 0;
rfxTileSet.tiles[0].xIdx = 0;
rfxTileSet.tiles[0].yIdx = 0;
rfxTileSet.tiles[0].YLen = (ushort)yData.Length;
rfxTileSet.tiles[0].CbLen = (ushort)cbData.Length;
rfxTileSet.tiles[0].CrLen = (ushort)crData.Length;
rfxTileSet.tiles[0].YData = yData;
rfxTileSet.tiles[0].CbData = cbData;
rfxTileSet.tiles[0].CrData = crData;
rfxTileSet.tilesDataSize = rfxTileSet.tiles[0].BlockT.blockLen;
rfxTileSet.CodecChannelT.blockLen = 22 + 5 + rfxTileSet.tilesDataSize;
return rfxTileSet;
}
private static bool IsCausalClusterInstance(KernelContext kernelContext)
{
OperationalMode thisMode = kernelContext.DatabaseInfo().OperationalMode;
return(OperationalMode.core.Equals(thisMode) || OperationalMode.read_replica.Equals(thisMode));
}
public void Rdprfx_HeaderMessage_PositiveTest_OrderTest_VersionsContextChannels()
{
#region Test Description
/*
Step 1: [RDPBCGR] establishing the connection.
Step 2: [RDPBCGR] send Frame Maker Command (Begin) to SUT.
Step 3: [RDPRFX] Send Encode Header Messages to SUT in order of TS_RFX_SYNC -> TS_RFX_VERSIONS -> TS_RFX_CONTEXT -> TS_RFX_CHANNELS.
Step 4: [RDPRFX] Send one frame of Encode Data Messages to SUT.
Step 5: [RDPBCGR] send Frame Maker Command (End) to SUT.
Step 6: [RDPRFX] Expect SUT sends a TS_FRAME_ACKNOWLEDGE_PDU.
*/
#endregion
#region Test Sequence
//Start RDP listening.
this.TestSite.Log.Add(LogEntryKind.Comment, "Starting RDP listening.");
this.rdpbcgrAdapter.StartRDPListening(transportProtocol);
#region Trigger client to connect
//Trigger client to connect.
this.TestSite.Log.Add(LogEntryKind.Comment, "Triggering SUT to initiate a RDP connection to server.");
triggerClientRDPConnect(transportProtocol);
#endregion
#region RDPBCGR Connection
//Waiting for the transport level connection request.
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting the transport layer connection request.");
this.rdpbcgrAdapter.ExpectTransportConnection(RDPSessionType.Normal);
//Set Server Capability with RomoteFX codec supported.
this.TestSite.Log.Add(LogEntryKind.Comment, "Setting Server Capability.");
setServerCapabilitiesWithRemoteFxSupported();
//Waiting for the RDP connection sequence.
this.TestSite.Log.Add(LogEntryKind.Comment, "Establishing RDP connection.");
this.rdpbcgrAdapter.EstablishRDPConnection(selectedProtocol, enMethod, enLevel, true, false, rdpServerVersion);
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Server Save Session Info PDU to SUT to notify user has logged on.");
this.rdpbcgrAdapter.ServerSaveSessionInfo(LogonNotificationType.UserLoggedOn, ErrorNotificationType_Values.LOGON_FAILED_OTHER);
#endregion
//Initial the RDPRFX adapter context.
rdprfxAdapter.Accept(this.rdpbcgrAdapter.ServerStack, this.rdpbcgrAdapter.SessionContext);
TS_RFX_ICAP[] clientSupportedCaps;
rdprfxAdapter.ReceiveAndCheckClientCapabilities(maxRequestSize, out clientSupportedCaps);
uint frameId = 0; //The index of the sending frame.
OperationalMode opMode = OperationalMode.ImageMode;
EntropyAlgorithm enAlgorithm = EntropyAlgorithm.CLW_ENTROPY_RLGR3;
ushort destLeft = 0; //the left bound of the frame.
ushort destTop = 0; //the top bound of the frame.
//Set OperationalMode/EntropyAlgorithm to valid pair.
if (clientSupportedCaps != null)
{
opMode = (OperationalMode)clientSupportedCaps[0].flags;
enAlgorithm = (EntropyAlgorithm)clientSupportedCaps[0].entropyBits;
}
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Frame Marker Command (Begin) with frameID: {0}.", frameId);
rdpbcgrAdapter.SendFrameMarkerCommand(frameAction_Values.SURFACECMD_FRAMEACTION_BEGIN, frameId);
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending one frame of encoded bitmap data to client. Operational Mode = {0}, Entropy Algorithm = {1}, destLeft = {2}, destTop = {3}.",
opMode, enAlgorithm, destLeft, destTop);
this.TestSite.Log.Add(LogEntryKind.Comment,
"Sending the encode header messages in the order of TS_RFX_SYNC -> TS_RFX_VERSIONS -> TS_RFX_CONTEXT -> TS_RFX_CHANNELS.");
rdprfxAdapter.SendTsRfxSync();
rdprfxAdapter.SendTsRfxCodecVersions();
rdprfxAdapter.SendTsRfxContext(opMode, enAlgorithm);
rdprfxAdapter.SendTsRfxChannels();
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending the encode data messages to client.");
rdprfxAdapter.SendTsRfxFrameBegin(0);
rdprfxAdapter.SendTsRfxRegion();
rdprfxAdapter.SendTsRfxTileSet(opMode, enAlgorithm, image_64X64);
rdprfxAdapter.SendTsRfxFrameEnd();
rdprfxAdapter.FlushEncodedData(destLeft, destTop);
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Frame Marker Command (End) with frameID: {0}.", frameId);
rdpbcgrAdapter.SendFrameMarkerCommand(frameAction_Values.SURFACECMD_FRAMEACTION_END, frameId);
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting TS_FRAME_ACKNOWLEDGE_PDU.");
rdprfxAdapter.ExpectTsFrameAcknowledgePdu(frameId, waitTime);
#endregion
}
public void Rdprfx_ImageMode_NegativeTest_TsRfxFrameBegin_InvalidBlockLen()
{
#region Test Description
/*
* Step 1: [RDPBCGR] establishing the connection.
* Step 2: [RDPRFX] send one frame of Encode Header and Data Messages to client, set the blockLen field of TS_RFX_FRAME_BEGIN to an invalid value (less than the actual).
* Step 3: [RDPRFX] expect the client terminates the RDP connection.
*/
#endregion
#region Test Sequence
//Start RDP listening.
this.TestSite.Log.Add(LogEntryKind.Comment, "Starting RDP listening.");
this.rdpbcgrAdapter.StartRDPListening(transportProtocol);
#region Trigger client to connect
//Trigger client to connect.
this.TestSite.Log.Add(LogEntryKind.Comment, "Triggering SUT to initiate a RDP connection to server.");
triggerClientRDPConnect(transportProtocol);
#endregion
#region RDPBCGR Connection
//Waiting for the transport level connection request.
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting the transport layer connection request.");
this.rdpbcgrAdapter.ExpectTransportConnection(RDPSessionType.Normal);
//Set Server Capability with RomoteFX codec supported.
this.TestSite.Log.Add(LogEntryKind.Comment, "Setting Server Capability.");
setServerCapabilitiesWithRemoteFxSupported();
//Waiting for the RDP connection sequence.
this.TestSite.Log.Add(LogEntryKind.Comment, "Establishing RDP connection.");
this.rdpbcgrAdapter.EstablishRDPConnection(selectedProtocol, enMethod, enLevel, true, false, rdpServerVersion);
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Server Save Session Info PDU to SUT to notify user has logged on.");
this.rdpbcgrAdapter.ServerSaveSessionInfo(LogonNotificationType.UserLoggedOn, ErrorNotificationType_Values.LOGON_FAILED_OTHER);
#endregion
//Initial the RDPRFX adapter context.
rdprfxAdapter.Accept(this.rdpbcgrAdapter.ServerStack, this.rdpbcgrAdapter.SessionContext);
receiveAndLogClientRfxCapabilites();
OperationalMode opMode = OperationalMode.ImageMode;
EntropyAlgorithm enAlgorithm = EntropyAlgorithm.CLW_ENTROPY_RLGR3;
ushort destLeft = 0; //the left bound of the frame.
ushort destTop = 0; //the top bound of the frame.
//Check if the above setting is supported by the client.
if (!this.rdprfxAdapter.CheckIfClientSupports(opMode, enAlgorithm))
{
enAlgorithm = EntropyAlgorithm.CLW_ENTROPY_RLGR1;
if (!this.rdprfxAdapter.CheckIfClientSupports(opMode, enAlgorithm))
{
this.TestSite.Log.Add(LogEntryKind.Comment, "Client does not support Image Mode, so stop running this test case.");
return;
}
}
this.TestSite.Log.Add(LogEntryKind.Comment, "Set the test type to {0}.", RdprfxNegativeType.TsRfxFrameBegin_InvalidBlockLen);
rdprfxAdapter.SetTestType(RdprfxNegativeType.TsRfxFrameBegin_InvalidBlockLen);
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Encode Header/Data Messages to client.");
rdprfxAdapter.SendImageToClient(image_64X64, opMode, enAlgorithm, destLeft, destTop);
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting the client terminates the RDP connection.");
bool bDisconnected = rdpbcgrAdapter.WaitForDisconnection(waitTime);
this.TestSite.Assert.IsTrue(bDisconnected, "Client is expected to drop the connection if received encode data in Video Mode when Image Mode is in effect.");
#endregion
}
public LuceneKernelExtension(File storeDir, Config config, System.Func <IndexConfigStore> indexStore, FileSystemAbstraction fileSystemAbstraction, IndexProviders indexProviders, OperationalMode operationalMode)
{
Org.Neo4j.Kernel.spi.explicitindex.IndexProviders proxyIndexProviders = CreateImposterOf(typeof(Org.Neo4j.Kernel.spi.explicitindex.IndexProviders), indexProviders);
@delegate = new Org.Neo4j.Kernel.Api.Impl.Index.LuceneKernelExtension(storeDir, config, indexStore, fileSystemAbstraction, proxyIndexProviders, operationalMode);
}
/// <summary>
/// Encode a bitmap data by RemoteFX codec.
/// </summary>
/// <param name="image"> The bitmap image to be sent </param>
/// <param name="opMode"> Indicate Operational Mode.</param>
/// <param name="entropy"> Indicate Entropy Algorithm.</param>
/// <param name="imgPos"> The top-left position of bitmap image relative to surface</param>
/// <param name="sId"> The surface Id that bitmap image is sent to </param>
/// <returns> A dictionary with frameId and byte stream frame pair </returns>
public Dictionary<uint, byte[]> RemoteFXCodecEncode(System.Drawing.Image image, OperationalMode opMode, EntropyAlgorithm entropy,
RDPGFX_POINT16 imgPos, ushort sId, PixelFormat pixFormat)
{
if (image == null) return null;
Dictionary<uint, byte[]> frDict = new Dictionary<uint, byte[]>(); // Save encoded frames for one tile
TileImage[] tileImageArr = RdprfxTileUtils.SplitToTileImage(image, RdprfxServer.TileSize, RdprfxServer.TileSize);
for (uint index = 0; index < tileImageArr.Length; index++)
{
byte[] tileBitmap = this.PackRfxTileImage(index, opMode, entropy, tileImageArr[index].image);
ushort tileLeft = (ushort)(imgPos.x + tileImageArr[index].x);
ushort tileTop = (ushort)(imgPos.y + tileImageArr[index].y);
RDPGFX_RECT16 tileRect = new RDPGFX_RECT16(tileLeft, tileTop,
(ushort)(tileLeft + tileImageArr[index].image.Width),
(ushort)(tileTop + tileImageArr[index].image.Height));
uint fid = MakeStartFramePdu();
MakeWireToSurfacePdu1(sId, CodecType.RDPGFX_CODECID_CAVIDEO, pixFormat, tileRect, tileBitmap);
MakeEndFramePdu(fid);
if (this.bcgrAdapter.SimulatedScreen != null)
{
this.bcgrAdapter.SimulatedScreen.RenderRemoteFXTile(sId, tileRect);
}
frDict.Add(fid, EncodePdusToSent());
}
return frDict;
}
private LuceneDataSource GetLuceneDataSource(Config config, OperationalMode operationalMode)
{
return(new LuceneDataSource(_directory.databaseLayout(), config, _indexStore, new DefaultFileSystemAbstraction(), operationalMode));
}
public abstract SbtResult SetOperationalMode(OperationalMode operationalMode);
public void Rdprfx_VerifyClientCapabilities()
{
#region Test Description
/*
* Step 1: trigger SUT initial a connection request.
* Step 2: continue the connection until Capabilities Exchange phase.
* Step 3: server sends Demand Active PDU to SUT.
* Step 4: Expect SUT responds a Confirm Active PDU and verify this PDU.
*/
#endregion
#region Test Sequence
//Start RDP listening.
this.TestSite.Log.Add(LogEntryKind.Comment, "Starting RDP listening.");
this.rdpbcgrAdapter.StartRDPListening(transportProtocol);
#region Trigger client to connect
//Trigger client to connect.
this.TestSite.Log.Add(LogEntryKind.Comment, "Triggering SUT to initiate a RDP connection to server.");
triggerClientRDPConnect(transportProtocol);
#endregion
#region Connection initialization phase
//Waiting for the transport level connection request.
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting the transport layer connection request.");
this.rdpbcgrAdapter.ExpectTransportConnection(RDPSessionType.Normal);
#region Connection Initiation phase
//Expect SUT send a Client X.224 Connection Request PDU.
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting SUT to send a Client X.224 Connection Request PDU");
this.rdpbcgrAdapter.ExpectPacket <Client_X_224_Connection_Request_Pdu>(waitTime);
//Respond a Server X.224 Connection Confirm PDU and set the EXTENDED_CLIENT_DATA_SUPPORTED flag.
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Server X.224 Connection Confirm PDU to SUT. Selected protocol: {0}; Extended Client Data supported: true", selectedProtocol.ToString());
this.rdpbcgrAdapter.Server_X_224_Connection_Confirm(selectedProtocol, true, true, NegativeType.None);
#endregion
#region Basic Setting Exchange phase
//Expect SUT send Client MCS Connect Initial PDU.
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting SUT to send a Client MCS Connect Initial PDU.");
this.rdpbcgrAdapter.ExpectPacket <Client_MCS_Connect_Initial_Pdu_with_GCC_Conference_Create_Request>(waitTime);
//Respond a Server MCS Connect Response PDU with GCC Conference Create Response.
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Server MCS Connect Response PDU to SUT. Encryption Method {0}; Encryption Level: {1}; RDP Version Code: {2}.", enMethod.ToString(), enLevel.ToString(), TS_UD_SC_CORE_version_Values.V2.ToString());
this.rdpbcgrAdapter.Server_MCS_Connect_Response(enMethod, enLevel, TS_UD_SC_CORE_version_Values.V2, NegativeType.None);
#endregion
#region Channel Connection phase
//Expect a Client MCS Erect Domain Request PDU.
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting SUT to send a Client MCS Erect Domain Request PDU.");
this.rdpbcgrAdapter.ExpectPacket <Client_MCS_Erect_Domain_Request>(waitTime);
//Expect a Client MCS Attach User Request PDU
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting SUT to send a Client MCS Attach User Request PDU.");
this.rdpbcgrAdapter.ExpectPacket <Client_MCS_Attach_User_Request>(waitTime);
//Respond a Server MCS Channel Join Confirm PDU.
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Server MCS Channel Join Confirm PDU to SUT.");
this.rdpbcgrAdapter.MCSAttachUserConfirm(NegativeType.None);
//Expect SUT start a channel join sequence
this.TestSite.Log.Add(LogEntryKind.Comment, "Expect SUT to start the channel join sequence.");
this.rdpbcgrAdapter.ChannelJoinRequestAndConfirm(NegativeType.None);
#endregion
#region RDP Security Commencement phase
//Expects SUT continue the connection by sending a Client Security Exchange PDU
//(if Standard RDP Security mechanisms are being employed) or a Client Info PDU.
if (transportProtocol == EncryptedProtocol.Rdp)
{
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting SUT to send Client a Security Exchange PDU.");
this.rdpbcgrAdapter.ExpectPacket <Client_Security_Exchange_Pdu>(waitTime);
}
#endregion
#region Secure Setting Exchange phase
//Expect a Client Info PDU.
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting SUT to send Client a Client Info PDU.");
this.rdpbcgrAdapter.ExpectPacket <Client_Info_Pdu>(waitTime);
#endregion
#region Licensing phase
//Send SUT a Server License Error Pdu - Valid Client.
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending a Server License Error Pdu - Valid Client to SUT.");
this.rdpbcgrAdapter.Server_License_Error_Pdu_Valid_Client(NegativeType.None);
#endregion
#region Capabilities Exchange phase
//Set Server Capability with RomoteFX codec supported.
this.TestSite.Log.Add(LogEntryKind.Comment, "Setting Server Capability. Server advertises the support for MS-RDPRFX.");
setServerCapabilitiesWithRemoteFxSupported();
//Send a Server Demand Active PDU to SUT.
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending a Server Demand Active PDU to SUT.");
this.rdpbcgrAdapter.Server_Demand_Active(NegativeType.None);
//Expect SUT respond a Client Confirm Active PDU.
//Once the Confirm Active PDU has been sent, the client can start sending input PDUs (see section 2.2.8) to the server.
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting SUT to send a Client Confirm Active PDU.");
this.rdpbcgrAdapter.ExpectPacket <Client_Confirm_Active_Pdu>(waitTime);
#endregion
//Initial the RDPRFX adapter context.
this.rdprfxAdapter.Accept(this.rdpbcgrAdapter.ServerStack, this.rdpbcgrAdapter.SessionContext);
//Verify the Client capabilites.
TS_RFX_ICAP[] supportedRfxCaps;
this.rdprfxAdapter.ReceiveAndCheckClientCapabilities(maxRequestSize, out supportedRfxCaps);
if (supportedRfxCaps != null)
{
foreach (TS_RFX_ICAP iCap in supportedRfxCaps)
{
OperationalMode opMode = (OperationalMode)iCap.flags;
EntropyAlgorithm enAlg = (EntropyAlgorithm)iCap.entropyBits;
this.TestSite.Log.Add(LogEntryKind.Comment, "Client supports ({0}, {1}).", opMode, enAlg);
}
}
#endregion
#endregion
}
public void Rdprfx_ImageMode_PositiveTest_RLGR3()
{
#region Test Description
/*
* Step 1: [RDPBCGR] establishing the connection.
* Step 2: [RDPBCGR] send Frame Maker Command (Begin) to SUT.
* Step 3: [RDPRFX] Send Encode Header Messages to SUT.
* Step 4: [RDPRFX] Send one frame of Encode Data Messages (encoded with RLGR3) to SUT.
* Step 5: [RDPBCGR] send Frame Maker Command (End) to SUT.
* Step 6: [RDPRFX] Expect SUT sends a TS_FRAME_ACKNOWLEDGE_PDU.
*/
#endregion
#region Test Sequence
//Start RDP listening.
this.TestSite.Log.Add(LogEntryKind.Comment, "Starting RDP listening.");
this.rdpbcgrAdapter.StartRDPListening(transportProtocol);
#region Trigger client to connect
//Trigger client to connect.
this.TestSite.Log.Add(LogEntryKind.Comment, "Triggering SUT to initiate a RDP connection to server.");
triggerClientRDPConnect(transportProtocol, true);
#endregion
#region RDPBCGR Connection
//Waiting for the transport level connection request.
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting the transport layer connection request.");
this.rdpbcgrAdapter.ExpectTransportConnection(RDPSessionType.Normal);
//Set Server Capability with RomoteFX codec supported.
this.TestSite.Log.Add(LogEntryKind.Comment, "Setting Server Capability.");
setServerCapabilitiesWithRemoteFxSupported();
//Waiting for the RDP connection sequence.
this.TestSite.Log.Add(LogEntryKind.Comment, "Establishing RDP connection.");
this.rdpbcgrAdapter.EstablishRDPConnection(selectedProtocol, enMethod, enLevel, true, false, rdpServerVersion);
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Server Save Session Info PDU to SUT to notify user has logged on.");
this.rdpbcgrAdapter.ServerSaveSessionInfo(LogonNotificationType.UserLoggedOn, ErrorNotificationType_Values.LOGON_FAILED_OTHER);
#endregion
//Initial the RDPRFX adapter context.
rdprfxAdapter.Accept(this.rdpbcgrAdapter.ServerStack, this.rdpbcgrAdapter.SessionContext);
receiveAndLogClientRfxCapabilites();
uint frameId = 0; //The index of the sending frame.
OperationalMode opMode = OperationalMode.ImageMode;
EntropyAlgorithm enAlgorithm = EntropyAlgorithm.CLW_ENTROPY_RLGR3;
ushort destLeft = 64; //the left bound of the frame.
ushort destTop = 64; //the top bound of the frame.
//Check if the above setting is supported by the client.
if (!this.rdprfxAdapter.CheckIfClientSupports(opMode, enAlgorithm))
{
this.TestSite.Log.Add(LogEntryKind.Comment, "the input pair of Operational Mode ({0}) / Entropy Algorithm ({1}) is not supported by the client, so stop running this test case.", opMode, enAlgorithm);
return;
}
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Frame Marker Command (Begin) with frameID: {0}.", frameId);
rdpbcgrAdapter.SendFrameMarkerCommand(frameAction_Values.SURFACECMD_FRAMEACTION_BEGIN, frameId);
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending one frame of encoded bitmap data to client. Operational Mode = {0}, Entropy Algorithm = {1}, destLeft = {2}, destTop = {3}.",
opMode, enAlgorithm, destLeft, destTop);
rdprfxAdapter.SendImageToClient(image_64X64, opMode, enAlgorithm, destLeft, destTop);
this.TestSite.Log.Add(LogEntryKind.Comment, "Sending Frame Marker Command (End) with frameID: {0}.", frameId);
rdpbcgrAdapter.SendFrameMarkerCommand(frameAction_Values.SURFACECMD_FRAMEACTION_END, frameId);
this.TestSite.Log.Add(LogEntryKind.Comment, "Expecting TS_FRAME_ACKNOWLEDGE_PDU.");
rdprfxAdapter.ExpectTsFrameAcknowledgePdu(frameId, waitTime);
this.TestSite.Log.Add(LogEntryKind.Comment, "Verify output on SUT Display if the verifySUTDisplay entry in PTF config is true.");
Rectangle compareRect = new Rectangle(destLeft, destTop, image_64X64.Width, image_64X64.Height);
this.VerifySUTDisplay(true, compareRect);
#endregion
}
private DatabaseInfo(Edition edition, OperationalMode operationalMode)
{
this.Edition = edition;
this.OperationalMode = operationalMode;
}
