Pierre Rebours's Log - Thoughts on Engineered Software

Coalesce in SAS

admin — Sun, 12 Feb 2012 07:49:31 +0000

Published in:

Coalescing refers to the process of checking the value of each input parameter in the order in which they are listed and returns the first non-missing value. In SAS, the behavior of each of the coalesce functions depends on the processing context, either in a data step or in a PROC SQL statement. These differences are important to acknowledge, especially when the code is migrated from PROC SQL to a data step.

Suppose, for example, that the following piece of code needs to be modified into a data step:

proc sql;
  create table foo2 as
  select coalesce(colum1, column2) as coalesce_column
  from foo;
quit;

The intuitive approach would be to simply rewrite the code as follows:

data foo2;
  set foo;
  coalesce_column = coalesce(colum1, column2);
run;

Although this approach seems to be correct at first glance, it may cause a potential issue: the coalesce function in the context of a data step treats parameters as numeric values. More specifically, if column1 and column2 are characters, the automatic SAS conversion kicks in by trying to convert these values to numerics. If such a conversion fails, a null value will be passed to the function. Simply switching to the character-compatible function, coalescec, may still have some side-effects as we will demonstrate in the following sections.

This article is therefore intended to review the behavior of the various coealesce functions in SAS, and to outline the hurdles when using these functions. All the examples will be driven from the following base table:

%let c_long_var_length = 300;
%let n_short_var_length = 3;
 
data root(drop=i character_to_append);
	*character variables;
	c_var_short = 'ABCDEFGHIJKLMN';
 
	*create and populate a string which has a size greater than 200;
	length c_var_long $&c_long_var_length;
 
	do i = 1 to &c_long_var_length;
		character_to_append = '*';
		if i = 1 then do;
			character_to_append = '>';
		end;
		else if i = &c_long_var_length then do;
			character_to_append = '<';
		end;
		c_var_long = cats(c_var_long, character_to_append);
	end;
 
	*numeric variables;
	length n_var_long 8;
	n_var_long = 10.2364545841;
	length n_var_short &n_short_var_length;
	n_var_short = 10;	
run;

The base table will allow us to study the behaviors of the various coalesce functions with variables of different lengths and types as summarized as follows:

Variable	Type	Length
c_var_long	Char	300
c_var_short	Char	14
n_var_long	Num	8
n_var_short	Num	3

Coalesce in a data step

In order to coalesce data in a data step, SAS offers two options:

coalesce(argument-1<..., argument-n>). All the arguments need to be numeric.
coalescec( argument-1<..., argument-n>). It performs a similar functionality for character arguments.

`coalescec` in a data-step

It is important to note that if the coalescec function returns a value to a variable that has not previously been assigned a length, then that variable is given a length of 200 bytes. As a consequence, if one of the arguments has a length above 200 characters, the result may be truncated. To avoid any data truncation, the length of the output variable needs to be set ahead of the function call.

data coalescec_with_data_step;
	set root(drop=n_var:);
 
	/*The resulting variable has a length of 200. 
           Note that it has not the same length of the parameters of the function*/
	coalescec_empty_with_c_short = coalescec('', c_var_short);	
 
	*the resulting variable is truncated as it has a length of 200 by default;
	coalescec_empty_with_c_long = coalescec('', c_var_long);
 
	length coalescec_empty_with_c_long2 $&c_long_var_length;
	coalescec_empty_with_c_long2 = coalescec('', c_var_long);
run;

The resulting dataset has the following structure:

Variable	Type	Length
c_var_long	Char	300
c_var_short	Char	14
coalescec_empty_with_c_long	Char	200
coalescec_empty_with_c_long2	Char	300
coalescec_empty_with_c_short	Char	200

Using the coalescec function with a parameter of size greater than 200 (here, c_var_long) will return by default a result with a length of 200. Setting explicitly the size of the output variable through the length statement is the only way to prevent a possible truncation.

`coalesce` in a data-step

The coalesce function accepts only numerics and returns by default a numeric of length 8, even if the underlying parameters have a shorter length. Unlike its sibling character-based function, there is no risk of truncation as the maximum length for a numeric in SAS is 8. Specifying the length of the return value in advance allows however the user to have full control of the length of the result.

data coalesce_with_data_step;
	set root(drop=c_var:);
 
	*the result has a length of 8 (default);
	coalesce_empty_with_n_short = coalesce('', n_var_short);	
 
	coalesce_empty_with_n_long = coalesce('', n_var_long);	
 
	*the resulting variable is truncated;
	length coalesce_empty_with_n_long2 3;
	coalesce_empty_with_n_long2 = coalesce('', n_var_long);
run;

Note that the third variable of the output table (coalesce_empty_with_n_long2) is not equal anymore to n_var_long as the numeric has been truncated. Truncating non-integers is not recommended due to the lost of precision.

Name	Value	Type	Length
coalesce_empty_with_n_short	10	Num	8
coalesce_empty_with_n_long	10.236455	Num	8
coalesce_empty_with_n_long2	10.236328	Num	3

Coalescing in a SQL-Step

`coalescec` in SQL

The coalescec function is still available in the context of a PROC SQL statement. Similarly to the data step, setting explicitly the length through the column attribute may avoid an undesired truncation.

proc sql;
	create table coalescec_with_sql_step as
	select coalescec('', c_var_short) as coalescec_empty_with_c_short,
			/*the data will be truncated to 200 characters, like in the DATA-step*/
			coalescec('', c_var_long) as coalescec_empty_with_c_long,		
			/*in order to avoid truncation, the length needs to be specified*/	
			coalescec('', c_var_long) as coalescec_empty_with_c_long2 length=&c_long_var_length		
	from root
	;
quit;

The output table is structured as follows:

Variable	Type	Length
coalescec_empty_with_c_long	Char	200
coalescec_empty_with_c_long2	Char	300
coalescec_empty_with_c_short	Char	200

`coalesce` in SQL

It is recommended to use the coalesce SQL function for both numeric and character variables as SAS determines then the type of the output column based on the types of the arguments. While you need to use two functions, one for each data type, to coalesce variables in a data step, only one function is required in SQL.

Choosing the coalesce function over the coalescec function shifts the responsibility of defining the result type to the SQL processor. This behavior is in line with the SQL standard.

proc sql;
	create table coalesce_with_sql_step as
	select coalesce('', c_var_short) as coalesce_empty_with_c_short,
			coalesce('', c_var_long) as coalesce_empty_with_c_long,
			coalesce('', c_var_short) as coalesce_empty_with_c_short2 length=5,
 
			coalesce(., n_var_long) as coalesce_empty_with_n_long,			
			coalesce(., n_var_short) as coalesce_empty_with_n_short,
			coalesce(., n_var_long) as coalesce_empty_with_n_long2 length=3,	
			coalesce(., n_var_short) as coalesce_empty_with_n_short2 length=3
	from root
	;
quit;

Note that the length of the ouput column is equal to the maximum length of the input parameters.

Variable	Type	Length
coalesce_empty_with_c_long	Char	300
coalesce_empty_with_c_short	Char	14
coalesce_empty_with_c_short2	Char	5
coalesce_empty_with_n_long	Num	8
coalesce_empty_with_n_long2	Num	3
coalesce_empty_with_n_short	Num	8
coalesce_empty_with_n_short2	Num	3

Type Conversion

We have covered so far the use of the coalesce functions when all the parameters are of the same type. Let’s review the behaviours when there is a type mismatch.

Mixing Types in a data-step

In a data-step, the arguments are converted if required. More specifically, if an numeric argument is used with the coalescec function, SAS will convert it to a character variable. Such a conversion is straightforward and is unlikely to fail. SAS will issue however a note in the log. With the coalesce function, SAS will try to convert a character variable into a numeric variable. If such a conversion fails, the argument will be set to NULL.

data coalesce_type_issues;
	set root;
 
	*SAS is converting the numerical parameter as a string and issue a note;
	coalescec_c_short_with_n_short = coalescec(c_var_short, n_var_short);
 
        /*SAS is trying to convert the character parameter as a numerical. 
           The conversion fails, and the converted value is set to null */
	Therefore the returned value is equal to the value of the second parameter;
	coalesce_c_short_with_n_short = coalesce(c_var_short, n_var_short);
run;

Running the previous piece of code will produce the following entry in the log:

NOTE: Numeric values have been converted to character values at the places given by: (Line):(Column). 89:40
NOTE: Character values have been converted to numeric values at the places given by: (Line):(Column). 92:31
NOTE: Invalid numeric data, c_var='string value', at line 92 column 31.
c_var=string value n_var=10.3
c_long_var=&gt;******************************************************************************************
******************************************************************************************************
******************************************************************************************************
****&lt; coalescec_c_with_n=string value coalesce_c_with_n=10.3
_ERROR_=1 _N_=1

Mixing types in SQL

While SAS will attempt to convert the parameters to the appropriate types, the coalesce function generates an error if there is a mismatch.

proc sql;
	select coalesce(c_var_short, n_var_short) as coalesce_c_with_n	
	from root
	;
 
	select coalesce(n_var_short, c_var_short) as coalesce_n_with_c
	from root
	;
 
	select coalescec(n_var_short, n_var_short) as coalescec_n_with_n
	from root
	;
quit;

The previous piece of code will issue three consecutive errors of the same type:

ERROR: The COALESCE function requires its arguments to be of the same data type.

Summary

The following table summarizes the differences between coalesce and coalescec depending on the context of the processing step. These differences are critical to keep in mind especially when code is being re-factored to use a different processing context.

Context	DATA Step		SQL Step
Function	`coalesce`	`coalescec`	`coalesce`	`coalescec`
Type of the Parameters	Numeric	Character	Character or Numeric. All the parameters need to be of the same type.	Character
Result Length	8 by default unless specified otherwise	200 by default unless specified otherwise	The length is adjusted based on the length of the parameters	200 by default unless specified otherwise
Risk if length is not specified	No loss of precision	Possible truncation	No loss of precision	Possible truncation
Type Conversion	Conversion from character to numeric may fail. Generates a note in the log.	Automatic conversion. Generates a note in the log.	Generates an error if there is an issue with conversion.	Automatic conversion. Generates a note in the log.

Attachment	Size
PDF Output	164.47 KB
SAS Log	12.27 KB
SAS Program	4 KB

Slide Number in PowerPoint

admin — Sat, 28 Jan 2012 18:18:20 +0000

Published in:

Microsoft PowerPoint

Recently, I was working on a PowerPoint presentation based on a specific template from a client. As I was about to print the deck, I realized that the slide numbers were missing. As I struggled to figure out how to make the slide number to appear on all the slides, I thought it would be good to share here my experiences. The illustrative screenshots have been taken from PowerPoint 2003. The approach should be similar for more recent versions of PowerPoint.

Configuring the Master Slides

The first step consists in editing your Master slides. Each presentation can have multiple masters. Usually, the masters come in pair:

The slide master is the first slide visible from the preview pan.
The title master is the second slide visible just below the slide master in the preview pan. The title master is optional.

Hovering the mouse indicates the type of the master. Furthermore, the pair is indicated by an icon connecting the two masters.

These masters come in pair as indicated by the icon joining the two slides

The master slide contains specific areas for the title, the body, the date, the footer, and the slide number. Each of these areas can be moved around. It is always worth checking if all the areas are enabled on the master slide by opening the Master Layout dialog box. This dialog box contains a list of check boxes, one for each area. When checked, he check boxes are disabled, which is a little bit counter intuitive. To hide an area, you have to select it and then delete it. To make an area visible again, open the "Master Layout" dialog and check the related box which should be now enabled.


The Slide Number is enabled, and visible on the master	The Slide Number is disabled, and not visible on the master

It is always good practice to rename the master slide, especially if your PowerPoint file contains many master models. This comes handy to associate a master model to the slides.

Renaming the Master model

Configuring the Slides

Once the layout areas have been positioned properly or removed, the slides themselves need to configured. Each slide is associated to a design layout and a text layout. The design layout allows choosing which master to apply to the slide. The text layout determines which member of the master pair will be applied (i.e. the slide master or the title master).


Design Layout (CustomMaster1 is selected)	Text Layout (The title master is selected)

The master contains specific layout areas such as the date or the slide number, these areas need to be activated in the slides. The option is available in the "Header and Footer" dialog, accessible through the menu: "Insert > Slide Number".


Steps to make the master layout areas appear on the slides

As a consequence, the slide number will be displayed if it has been enabled through the "Slide Number" menu and if the slide number layout area has been made visible in the related master. This dual condition may be a little confusing: the user activates the slide number, but will not see the numbering as it has been disabled in the master.

The dialog "Header and Footer" gives however a visual clue using the preview:

	Slide Number: disabled	Slide Number: enabled
Slide Number in Master: enabled
Slide Number in Master: disabled

Understanding the factors contributing to the proper display of slide numbers, for example, allows really to understand key concepts related to themes in PowerPoint.

Attachment	Size
Example of a PowerPoint presentation	52 KB

Formatting scaled numbers

admin — Sun, 10 Jan 2010 19:28:44 +0000

Published in:

.NET

Standard formatting in .NET is sometimes not enough to fill specific requirements. For example, when high-level financial reports from big corporations need to be produced, the numbers dealt-with are generally around hundred of millions. Consider the following report where the scale and the currency (M$) is being displayed in the row header.

	Quarter 1	Quarter 2
New York (in M$)	102.76	21.40
Florida (in M$)	32.76	67.40

In order to achieve this formatting, a straightforward solution would be to apply a scaling factor to the numbers beforehand.

string.Format("{0:N2}", valueToFormat / 1000000);

Sometimes, it is not appropriate nor possible to scale the numbers. In this situation, number scaling using the "," custom specifier could be used. Note the use of two commas since the number to be formatted is divided by 1000 for each comma:

decimal valueToFormat = 1345278000.346M;
string.Format("0:#,#,,", valueToFormat ); // displays 1,345 with the invariant culture

Most of the examples found in the MSDN fail to explain how to scale the formatted number and keep the decimals at the same time. The trick is to add the "." custom specifier after the "," comma specifiers:

decimal valueToFormat = 1345278000.346M;
string.Format("0:#,#,,.00", valueToFormat ); // displays 1,345.28 with the invariant culture

This custom formatting technique, however, has some drawbacks:

It is harder to read than standard formatting such as {0:N} or {0:C}.
The output may not be consistent with the settings of some cultures. For example, forcing to display two decimal digits may not be compatible with the value of CultureInfo.NumberFormat.NumberDecimalDigits.
Finally, custom specifiers do not mix with the standard numeric specifiers. The currency symbol cannot be therefore displayed side-by-side with the number.

A custom formatter called NumberScalingFormatter has been hence developed to allow scaling the numbers while keeping the underlying settings of the culture. In order to use it, pass the ScalingFactor and the underlying culture. The following output illustrates the behavior of the custom formatter as well as the custom "," specifier combined with the "." specifier:

// string.Format(CultureInfo.InvariantCulture,{0:N}, 1345278000.346): 
	1,345,278,000.35
// string.Format(CultureInfo.InvariantCulture,{0:#,#,,}, 1345278000.346): 
	1,345
// string.Format(CultureInfo.InvariantCulture,{0:#,#,,.00}, 1345278000.346): 
	1,345.28
// string.Format(new CultureInfo("en-US"),{0:#,#,,.00}, 1345278000.346): 
	1,345.28
// string.Format(new CultureInfo("fr-FR"),{0:#,#,,.00}, 1345278000.346): 
	1 345,28
// string.Format(CultureInfo.InvariantCulture,{0:N}, 1345278000.346): 
	1,345,278,000.35
// string.Format(new NumberScalingFormatter(ScalingFactor.Million, CultureInfo.InvariantCulture),{0:N}, 1345278000.346): 
	1,345.28
// string.Format(new NumberScalingFormatter(ScalingFactor.Million, new CultureInfo("en-US")),{0:N}, 1345278000.346): 
	1,345.28
// string.Format(new NumberScalingFormatter(ScalingFactor.Million, new CultureInfo("fr-FR")),{0:N}, 1345278000.346): 
	1 345,28

For an introduction to custom formatter, please check out the post from David Hayden. A basic outline of the code follows.

public enum ScalingFactor
{
    None,
    Million,
    Billion
}
 
public class NumberScalingFormatter : IFormatProvider, ICustomFormatter
{
    private readonly CultureInfo _underlyingCulture;
    private readonly ScalingFactor _scalingFactor;
 
 
    public NumberScalingFormatter(ScalingFactor scalingFactor, CultureInfo underlyingCulture)
    {
        if (underlyingCulture == null)
        {
            throw new ArgumentNullException();
        }
        _scalingFactor = scalingFactor;
        _underlyingCulture = underlyingCulture;
    }
 
    public ScalingFactor Factor
    {
        get
        {
            return _scalingFactor;
        }
    }
 
    public CultureInfo Culture
    {
        get
        {
            return _underlyingCulture;
        }
    }
 
 
    #region IFormatProvider Members
 
    public object GetFormat(Type formatType)
    {
        object formatter = null;
        if (formatType == typeof(ICustomFormatter))
        {
            formatter = this;
        }
        else
        {
            formatter = _underlyingCulture.GetFormat(formatType);
        }
        return formatter;
    }
 
    #endregion
 
    #region ICustomFormatter Members
    private int GetUnderlyingThousandScalingFactor()
    {
        int underlyingThousandScalingFactor;
 
        switch (_scalingFactor)
        {
            case ScalingFactor.None:
                underlyingThousandScalingFactor = 0;
                break;
 
            case ScalingFactor.Billion:
                underlyingThousandScalingFactor = 3;
                break;
 
            default:
            case ScalingFactor.Million:
                underlyingThousandScalingFactor = 2;
                break;
        }
        return underlyingThousandScalingFactor;
    }
 
    private object Scale(object arg)
    {
        object scaledValue = null;
 
        if (arg == null)
        {
            scaledValue = null;
        }
        else if (_scalingFactor == ScalingFactor.None)
        {
            scaledValue = arg;
        }
        else
        {
            int underlyingThousandScalingFactor = GetUnderlyingThousandScalingFactor();
            try
            {
                double convertedValue = Convert.ToDouble(arg);
                scaledValue = Math.Pow(10, underlyingThousandScalingFactor * -3) * convertedValue;
            }
            catch (InvalidCastException)
            {
 
            }
        }
        return scaledValue;
    }
 
    public string Format(string format, object arg, IFormatProvider formatProvider)
    {
        StringBuilder formattableString = new StringBuilder("{0");
        if (!string.IsNullOrEmpty(format))
        {
            formattableString.Append(":");
            formattableString.Append(format);
        }
        formattableString.Append("}");
 
        return string.Format(_underlyingCulture, formattableString.ToString(), Scale(arg));
    }
 
    #endregion
}

The source code as well as the NUnit test cases are available from the SVN directory. Please refer to the instruction to download the tarballs.

MWSnap Review

admin — Tue, 06 Jan 2009 06:30:51 +0000

Published in:

Screenshot

Stories:

Review

When it comes to create screenshots, I often use MWSnap, a freeware written by Mirek Wojtowicz. This tool offers all the core functionalities one may expect from a screenshot application. MWSnap was recommended to me by Michael Olivero.

MWSnap start page

The tool allows snapping variable rectangle areas as well as entire windows and menus. The snapped images can then be saved as jpeg or png. The ability to edit the snapshot by adding cursors is handy to document user interaction. Finally, the auto-saving functionality with auto-generated file names will increase productivity for high-volume scenarios.

Cursors

Auto-Saving

MWSnap has been released before the advent of Vista. Under Vista, most of the functionalities of MWSnap work, but some glitches are expected when snapping windows and menus.

Order returned by GetMethods

admin — Mon, 29 Dec 2008 16:15:42 +0000

Published in:

.NET

CLR

Reflection

When calling the GetMethods function which lists the methods for a given type, we should keep in mind that this function does not return methods in a particular order. More specifically, the methods are not necessarily in the same order it has been declared in the source code. This discrepancy is due to some caching performed by the .NET Framework for better performance as explained in a post by Haibo Luo. This article is aimed at outlining solutions to order the methods returned by GetMethods in the declaring order.

Returned Index vs. Ordered Index

Even when reflection operations are executed on a CLR type for the first time, i.e., when the cache is empty, the order returned by GetMethods may not be the same as the declaration order. In the following example, a class with 200 randomly generated methods has been compiled. Each method has the same signature:

public class Test {
  public decimal AJODCUJQ(int parameter) {
    throw new NotImplementedException();
  }
 
 // 199 other methods with the same signature follow
}

View of the class using Reflector

The following call to GetMethods returns 200 MethodInfo instances.

typeof(Test).GetMethods(BindingFlags.Instance | 
                                         BindingFlags.Static | 
                                         BindingFlags.Public | 
                                         BindingFlags.DeclaredOnly);

The returned order is however different than the declared order. The first declared function (index #0) is returned as the 116th method. Several cut-offs points are visible: methods #170 to #199 are the first returned, followed by methods #85 to #169, then by methods #0 to 84. Such behaviors may not be noticeable for types having a smaller numbers of methods.

Returned Index vs. Declared Indexes (see data file)

Solutions

Code using GetMethods cannot depend on the order in which methods are returned, because that order varies. Several strategies could be implemented to order the methods in the declaring order, i.e., the xth method declared in the original source code will be the xth method being returned.

MetaData Token

The first solution could use the MetaDataToken property of MethodInfo. A metadata token is used to locate the record that contains the metadata for an entity such as a type, a method, or a field. The metadata engine uses the token to index into a specific metadata table in a given metadata scope. By experience, we can observe a direct correlation between the value of the metadata token and the declared index of the related method. I have not found, however, the confirmation of such a behavior in the documentation and I cannot therefore advice to use this trick for production systems.

Visual Studio Automation

If the developed application can run in the context of Visual Studio, using Visual Studio Automation offers a rich alternative to reflection. Using this framework is, however, outside the scope of this article.

ICorDebug

ICorDebug is a managed debugging public API. MDbg, which can be downloaded from the Microsoft site, simplifies the functionalities by wrapping ICorDebug in a much simplier object model. Mike Stall provides an example which loads a pdb file and outputs the symbols as a XML file. In this example, it is shown how the MDbg API can extract the line numbers where the method has been declared. By using the information provided by MDbg, the methods returned by GetMethods can be sorted in the declaring order.

Implementation

The implementation relies on a core of services defined as interfaces:

public interface IMethodProvider
{
    MethodInfo[] GetMethods(Type type);
}
public interface IMethodFilter
{
   bool IsMatch(MethodInfo methodInfo);
   void Initialize();
}
public interface ILineNumberProvider
{
   int GetStartLineNumber(MethodInfo method);
}

The service which returns an array of methods is called IMethodProvider. A simple implementation of this service is done by PublicReflectionMethodProvider which directly calls GetMethods. This implementation, as we have seen it previously, does not guaranty that the methods will be sorted in the same order as they have been declared. OrderedMethodProvider implements also IMethodProvider but returns ordered methods thanks to the help of an inner service ILineNumberProvider. ILineNumberProvider is implemented by MDbgLineNumberProvider which extracts the line number by using the MDbg library. If the pdb file related to the MethodInfo does not exist, a FileNotFoundException is thrown. Note that other implementations could use the metadata token or Visual Studio Automation.

Class Diagram

The source code as well as the NUnit test cases are available from the SVN directory. Please refer to the instruction to download the tarballs.

Attachment	Size
Returned vs. Declared Ordering (CSV file)	2.27 KB

CanShrink and CanGrow Behaviors

admin — Mon, 22 Dec 2008 11:09:38 +0000

Published in:

SSRS

SSRS 2005

In Reporting Services (SSRS), the CanGrow property indicates whether the size of the text box can increase vertically according to its content. Similarly, CanShrink decreases the height of the text box according to its content. Controlling dynamically the height of report elements is only possible through these properties since the Height property cannot be bound to an expression. These two properties are therefore useful to create reports which can be scaled to both small and large contents. Unfortunately, CanGrow and CanShrink behave differently for each rendering extension.

Report testing the behaviors of CanGrow and CanShrink

Let's demonstrate such behaviors with a report created with SSRS 2005. The following elements have been created without any padding:

A text box with a non-empty value (Value = "Content") and CanShrink set to true.
A text box with a non-empty value (Value = "Content") and CanGrow set to true.
A text box with a non-empty value (Value = "Content") where CanShrink and CanGrow are both set to true.
A text box with an empty value and CanShrink set to true.
A text box with a single space as value (Value = " ") where CanShrink is set to true.
A non-visible text box (Visibility.Hidden = true).
A non-visible text box where CanShrink is set to true.

The FontSize can be changed using a report parameter

The FontSize property of each text box is bound to FontSize report parameter (= Parameters!FontSize.Value). The available values are 6pt, 10pt, 16pt, and 30pt.

Rendering Extensions

First, let's have a look on how the report is rendered with IE 7.

6pt	10pt
16pt	30pt

Rendering with IE 7

CanGrow and CanShrink behave as expected for all the text boxes having a non-empty Value. The shrinkable text box cuts off content too big for the specified height. Similarly, the text box which can only grow has its height unchanged when the FontSize is equal to 10pt. Notice that the text box, which can shrink but has no value, does not have its height changed. The Value property needs to have a space to have its height resized to zero.

Rendering with PDF

The PDF rendering is the most accurate. Similarly to the HTML rendering, the CanGrow and CanShrink modify the heights of the text boxes as expected. Furthermore, the text box with an empty Value has been removed from the flow of the document. On the other hand, the hidden text boxes continue to occupy some real-estate on the report. Combining the CanShrink property with just a space for the Value property does not, however, hide the text box contrarily to the HTML rendering.

Rendering with Excel

Finally, it is obvious with the Excel rendering that the CanGrow and CanShrink properties fail to adjust the height of the Excel rows. It is a frustrating limitation of the Excel rendering.

Conclusions

When using CanGrow and CanShrink, be aware what their behaviors can change depending on the rendering extension being used:

CanShrink will remove the text box from the document flow for only specific rendering format.
No Value property may cause some issues.
The Visibility property seems to override the intended behavior of CanShrink .
Padding needs to be set to zero to fully hide a shrinkable element.

Attachment	Size
Report testing CanGrow and CanShrink	8.78 KB

Load Testing using The Grinder

admin — Tue, 16 Dec 2008 15:51:04 +0000

Published in:

Performing preliminary load testing on web applications does not require the use of complex tools such as Load Runner. An open-source tool called The Grinder provides a simple way for developers to perform load testing before handing out the application to Quality Assurance. With The Grinder, the load tests are defined using Jython scripts, and then are run by agents which could be distributed over the network. A property file defines which load tests should be run, how many times, and on how many threads. A central application referred to as the console starts the agents, collects the responses, and monitors the number of requests per second (RPS). The authors of this tool provide a short but useful overview of the architecture.

Installing The Grinder is a matter of unzipping the archive since the tool is written in Java. However, making the tool work as indented requires to dig into the documentation a little bit. This article is intended to assist people interested in getting up and running the tool on a Widows environment as quickly as possible.

The companion files are available from the SVN directory. Please refer to the instruction to download the tarballs.

Configuration

On my desktop, I have created a folder called grinder. The archive downloaded from Sourceforge was extracted in this folder as grinder-3.1. A couple of batch files will need to be created to conveniently start up the agents and the console. The first batch file setGrinderEnv.bat defines environment variables which will be reused:

set GRINDERPATH="C:\Documents and Settings\pierre rebours\Desktop\grinder\grinder-3.1"
set GRINDERPROPERTIES="C:\Documents and Settings\pierre rebours\Desktop\grinder\grinder.properties"
set CLASSPATH=%GRINDERPATH%\lib\grinder.jar;%CLASSPATH%

Since The Grinder is a Java-based tool, the infamous environment variable CLASS_PATH needs to be defined. The environment variable GRINDERPROPERTIES refers to the path of the property file. More about this file in a moment.

Starting the console is done using startConsole.bat:

call "C:\Documents and Settings\pierre rebours\Desktop\grinder\setGrinderEnv.cmd"
java -cp %CLASSPATH% net.grinder.Console

Similarly, startAgent.bat starts the agent(s)

call "C:\Documents and Settings\pierre rebours\Desktop\grinder\setGrinderEnv.cmd"
java -cp %CLASSPATH% net.grinder.Grinder %GRINDERPROPERTIES%

Property File

The load test is defined using the property file. The configuration entry grinder.script = http.py indicates the path of the Jython script which will be run. Other interesting configurations include the number of processes created by each agent (grinder.processes) and the number of threads for each process (grinder.threads).

I would also recommend to explicitly specify the log and the temporary directories:

# The directory in which worker process logs should be created. 
grinder.logDirectory = log
 
# Additional arguments to worker process JVMs.
grinder.jvm.arguments = -Dpython.cachedir="C:\\Documents and Settings\\pierre rebours\\Desktop\\grinder\\tmp"

Load Test Specification

Simulating a request to a web server could be defined as follows:

from net.grinder.script import Test
from net.grinder.script.Grinder import grinder
from net.grinder.plugin.http import HTTPPluginControl, HTTPRequest
from HTTPClient import NVPair
 
test1 = Test(1, "WebService")
request1 = test1.wrap(HTTPRequest())
 
class TestRunner:
	def __call__(self):		
		request1.GET("http://localhost/MyApplication/PresentationService.ashx")

A custom proxy server can also be defined. In the following case, the proxy is defined as localhost on port 8888 which is default the port Fiddler is listening to. The full name of the computer needs to be provided since Fiddler will bypass localhost.

# Import Directives
# ....
 
control = HTTPPluginControl.getConnectionDefaults()
control.setProxyServer("localhost", 8888)
control.setFollowRedirects(0)
 
test1 = Test(1, "WebService")
request1 = test1.wrap(HTTPRequest())
 
class TestRunner:
	def __call__(self):		
		request1.GET("http://MyComputer/MyApplication/PresentationService.ashx")

Adding a new request is a matter of creating a new test and wrap it as a HTTP request. The following script simulates two requests:

# Import Directives
# ....
 
test1 = Test(1, "WebService")
request1 = test1.wrap(HTTPRequest())
 
test2 = Test(1, "CSSFile")
request2 = test1.wrap(HTTPRequest())
 
class TestRunner:
	def __call__(self):		
		request1.GET("http://localhost/MyApplication/PresentationService.ashx")
                request2.GET("http://localhost/MyApplication/Style.css")

The load test can be written manually or can be generated through the TCP proxy provided with The Grinder. Starting the TCP proxy to generate the load case could be done through yet another batch file:

call "C:\Documents and Settings\pierre rebours\Desktop\grinder\setGrinderEnv.cmd"
java -cp %CLASSPATH% net.grinder.TCPProxy -console -http > proxy-output.py

Conclusion

The Grinder remains a simple tool to set up and start testing web applications under heavy load. Running Windows Performance Monitor in parallel allows correlating the number of requests per second (RPS) with underlying performance counters. I would recommend The Grinder to developers who would like to ensure that their web applications respond well under stress before handing them to more experimented testers knowing the in-and-outs of more sophisticated testing tools.

Context Connection and SQLCLR Functions

admin — Mon, 20 Oct 2008 16:48:00 +0000

Published in:

TSQL

.NET

SQLCLR

For one of the projects I have worked on recently, a set of variables needed to be computed for each product and for each month of the year on a regular basis. The product data was stored in SQL Server 2005 SP2. The computed volume was quite large since around 60 variables x 120 products x 12 months = 86,400 results needed to be calculated every time and be stored in the result table. The business requirements were the following:

The calculated variables were based on complex business rules which were quite tricky to be implemented in TSQL.
Each variable related to a product had to use input from various tables.
Variables related to a given product were independent of other products.
On the other hand, variables were sometimes based on others variables for the same product.

It was decided to express the business rules using a .NET language such as C# and to create a Table-Valued Function (TVF) using the CLR. Srinivas Sampath wrote a good introduction on how to implement a TVF in .NET.

The TVF called ufnComputeProduct takes the Product code as the only parameter. The function returns a table with the following columns: the Product code, the VariableName, the MonthID, and the VariableValue. A CROSS APPLY runs all the available products against the function and stores the result set in the VersionedResults table. As mentioned previously, this query would insert around 85,000 records every time.

INSERT INTO VersionedResults
	(ResultSetVersionID, Product, VariableName, MonthID, VariableValue)
	SELECT @ResultSetVersionID AS ResultSetVersionID,
			Result.Product,
			Result.VariableName, Result.MonthID, Result.VariableValue
	FROM Product
	CROSS APPLY ufnComputeProduct(Products.Product) AS Result

Computing all the variables related to a given product requires to pull various input data from the database. In the .NET code of the user-function, a stored procedure is called in order to return all the relevant input data. The context connection is used since the stored procedure and the CLR function are executed within the same pipe:

using (SqlConnection connection = new SqlConnection("context connection=true"))
using (SqlCommand sqlCommand = new SqlCommand())           
{
      connection.Open();
 
      // Execute the store procedure
}

Unfortunately, running the CROSS APPLY SQL statement returns the following error:

Msg 3991, Level 16, State 1, Procedure uspCompute, Line 60
The context transaction which was active before entering user defined routine, trigger or aggregate "ufnComputeProduct" has been ended inside of it, which is not allowed. Change application logic to enforce strict transaction nesting.
The statement has been terminated.

After searching on the Internet, I have discovered that this error message is also related to rollbacks within SQLCLR code (See transaction or trigger rollbacks). On the other hand, running the CROSS APPLY query without the INSERT statement does not raise any error. The problem is therefore related to the fact that the CLR function is called within the transaction scope of the INSERT statement. It turns out that the solution is not to close the context connection:

// We need to remove the connection out of the using statement
SqlConnection connection = new SqlConnection("context connection=true");
 
using (SqlCommand sqlCommand = new SqlCommand())           
{
      connection.Open();
 
      // Execute the store procedure
}
// It will work!

Calling methodically Dispose on all the disposable objects which have been created in our code has turned against us. I personally believe that calling Dispose on a context connection should not have any side effect. The SqlConnection implementation should have detected that is was a context connection and should have never closed the connection. The connection was created by SQL Server and should be closed by SQL Server, irregardless of the user code.

One could however argue that calling a stored procedure within a CLR function should not be allowed since calling a stored procedure within a TSQL function is not allowed in SQL Server. However, Herts Chen in an article on SQL Server 2000 mentioned workarounds with OPENQUERY. With SQL Server 2005, using stored procedures within a CLR function can be an acceptable workaround, as long as you are careful with the context connection.

Review of SQL Server 2005 Reporting Services, Essential Skills for Database Professionals

admin — Sat, 04 Oct 2008 08:55:59 +0000

Published in:

Stories:

As I wanted to have a complete view of the features delivered by SQL Server Reporting Services (SSRS in short), and yet knowing how to use the product in real-world scenarios, I got a book titled Microsoft SQL Server 2005 Reporting Services by Brian Larson.

The book is divided into three parts. All the examples are based on the Galaxy database, a fictional inter-galactic delivery service. The first version of the book was based on the sample database coming with SQL Server 2005, Adventure Works, but it seems that it was worth to develop a new sample database for the new edition of the book. But, it can make the TSQL queries a little bit harder to understand.

Part 1, Getting Started

The first chapters give you an overview of the architecture of the reporting tool, the installation, and the different options of deployment. It is enough for a solution architect to get a clear view of the components, but will probably fall short for a system administrator. Just for the record, the author states on p. 29 that the Report Builder is available only in the Enterprise version of SQL Server, which is not correct: the Standard Edition allows the use of the Report Builder as well.

Part 2, Report Authoring

The second part focuses on building the reports. The author goes through the wizards first, the basic reports from scratch, and finally advanced reporting. This part is where the value of the book lays. Each chapter guides us through the creation of reports from beginning to end. On average, the reader will be exposed to five to seven reports each chapter. Each report covers a specific set of functionalities in SSRS. By the end of the second part, you should know all the functionalities available in the Report Designer, and this is a good feeling.

The reader needs to be in front of the computer, because the book goes through all the steps to create the reports. At the end of each report built under the supervision of the author, there is a debriefing section called task notes which outlines the functionalities and tricks used for this report.

Being guided through the report step by step is fine at the beginning, but starts to be repetitive as most of the steps are atomic and repeated over and over. Count on having 50 steps on average for each report built. Some of the steps are about configuring the visual look of the report which is very frustrating from a developer perspective. On the other hand, this book may be perfect not for DBAs or developers, but the business users. All the steps are thoroughly explained and it is difficult to go off-track. Offer this book to your customer, and you will teach them how to fish their own advanced reports.

Part 3, Report Serving

The last part focuses on the Report Manager, the built-in website which is used to deploy and distribute the reports. Similarly to the second part, all the functionalities are covered through exercises. It is a part worth reading for people in charge of deploying and distributing reports. Report Manager is quite advanced in term of authorization and configuration, and could therefore be used as a front-end application for small-sized projects. The last chapter of the book focuses on the available options to integrate reports seamlessly with existing applications.

Annexes

Finally, appendixes cover the report definition language and the web service interface of the Report manager. These types of reference annexes are a good way to increase artificially the size of the book, and do not offer a terrific value. However, the last annex is about Report Builder, the Ad Hoc reporting tool for Power Users who do not have Report Designer and Visual Studio installed on their machine. The author goes also through the creation of the Report Model which is be the only type of data source that Report Builder can use.

I recommend this book for people wanted to author reports and deploys them. DBAs and developers may find the book to be a little bit slow, but they will get a good value by going through all the exercises.

Testing Equality Operators with NUnit

admin — Wed, 03 Sep 2008 18:26:13 +0000

Published in:

.NET

TDD

NUnit

Any class or structure in .NET can define the equality and inequality operators. Implementing such operators, however, can be error-prone. The operators therefore need to be validated by unit tests. We will first discuss the challenges of writing such unit tests. We will then review how just one new NUnit constraint can help writing thorough tests for the equality and inequality operators.

The implementations of the equality and inequality operators are presented below for a simple Customer class: two customers are expected to be equal if they have the same name. Refer to the Microsoft guidelines for further details.

class Customer
{
    private readonly string name;
 
    public Customer(string name)
    {
        if (name == null) { 
           throw new ArgumentNullException();
        } 
        this.name = name;
    }
 
    public string Name
    {
        get
        {
            return name;
        }
    }
 
    public override bool Equals(object obj)
    {
        Customer customer = obj as Customer;
        if (customer != null)
        {
            return this == customer;
        }
        else
        {
            return false;
        }
    }
 
    public override int GetHashCode()
    {
        return Name.GetHashCode();
    }
 
    public static bool operator ==(Customer lhs, Customer rhs)
    {
        if (object.ReferenceEquals(lhs, rhs))
        {
            return true;
        }
        else if ((object)lhs == null || (object)rhs == null)
        {
            return false;
        }
        else
        {
            return lhs.Name == rhs.Name;
        }
    }
 
    public static bool operator !=(Customer lhs, Customer rhs)
    {
        return !(lhs == rhs);
    }
}

Such implementations typically use lhs and rhs as names for the parameters of the equality and inequality operators. lhs is the abbreviation for left-hand side. Similarly, rhs stands for right-hand side. For the remaining of this discussion, equality operators will refer to both the equality and inequality operators.

Semantics of the Equality Operators

Equality operators allow to express equality relations between two objects using a more natural syntax than the overridden Equals method inherited from object, the base type of the .NET run-time. Fully supporting equality and inequality relations requires to respect three semantics: reflexivity, symmetry, and transitivity. Testing the semantics of the operators can be done with NUnit constraints. Given any references c1, c2, and c3 of type Customer, the equality operators should be:

reflexive.

Assert.That(c1 == c1, Is.True);
Assert.That(c1 != c1,  Is.False);

symmetric.

Assert.That( (c1 == c2 && c2 == c1) || (c1 != c2 && c2 != c1), Is.True);

transitive.

if (c1 == c2 && c2 == c3) {
   Assert.That(c1 == c3, Is.True);
}
if (c1 != c2 && c2 != c3) {
   Assert.That(c1 != c3, Is.True);
}

Equality operators in .NET should also behave in relation with the Equals and GetHashCode methods. Like the equality operators, Equals should also be reflective, symmetric, and transitive. Note that in the following piece of code, c1 and c2 are assumed to be non-null. Tests of the reflexivity, symmetry, and transitivity of Equals are also omitted for brevity here.

Assert.IsTrue( (c1 == c2 && c1.Equals(c2)) || (c1 != c2 && !c1.Equals(c2));
Assert.IsTrue( (c1 == c2 && c1.GetHashCode() == c2.GetHashCode()) || (c1 != c2 && c1.GetHashCode() == c2.GetHashCode());

Furthermore, any non-null reference c of type Customer should be expected not to be equal to the null reference.

Customer nullCustomer = null;
 
Assert.That(c.Equals(null), Is.False);
 
Assert.That(c == (Customer)null, Is.False);
Assert.That((Customer)null == c1, Is.False);
 
Assert.That(c != (Customer)null, Is.True);
Assert.That(c == (Customer)null, Is.False);

Similarly, the static equality operators should behave properly when all the input parameters are null. Testing such extreme cases is important as developers, including myself, sometimes forget to deal appropriately with null references.

Assert.That( (Customer)null == (Customer)null, Is.True);

Challenges of Testing

Using equality operators allows to create rich but syntaxically simple expressions which are easy to read and maintain. Therefore, an application may define a lot of equality operators. As mentioned previously, testing the newly implemented operators consists in testing if the operators respect the inherent semantics and are consistent with Equals and GetHashCode methods.

Testing properly the equality operators is finally more complex than expected as the number of potential cases to test is quite large. Furthermore, tests need also to be run for two references of Customer expected to be unequal. Consequently, the NUnit assertions should to be factorized in order to be reused across multiple test fixtures.

But Equality Operators are Resolved during Compilation

Consider the following first draft which attempts to factorize the assertions into the function AssertEqualityForEqualObject. This function is meant to test not only the Customer class, but also other types such as the Supplier class or the ZipCode structure for example. Since the only commonality between all the .NET types is the type object, our first draft will have two input parameters obj1 and obj2 of type object.

void AssertEqualityForEqualObject(object obj1, object obj2) {
   // Testing null arguments is omitted in this example
 
   Assert.That(obj1.Equals(obj2), Is.True); 
   Assert.That(obj2.Equals(obj1), Is.True);
   . . . .    
   // This statement will not work as indented!
   // Object.ReferenceEquals(obj1, obj2) will be called instead of Customer.operator==(obj1, obj2)
   Assert.That(obj1 == obj2, Is.True);
   . . . .

The second assert will not work as indented because the decision of choosing the appropriate static operator is made at compile-time. Hence, the equality operator defined for the type object will always be called at run-time. In other words, the second assertion just checks if obj1 and obj2 are the same reference.

Generics will not work either for the same reason: operator == is resolved at compilate-time, not at run-time. Compiling the following piece of code will lead to the following error: Operator '==' cannot be applied to operands of type 'T' and 'U'. Comments have been made on this issue.

class EqualityAssertion<T, U>
{
    public bool Test(T obj1, U obj2)
    {
        return obj1 == obj2;
    }
}

Value and Reference Types

As previously mentioned, it is important to test cases with null parameters. However, such tests on the equality operators is irrelevant for value types. Abstract Data Type (ADT) like the PostCode or Money structures usually rely on equality operators. But it is expected that testing the Equals method with a null parameter on a value type will always return false:

Assert.That(DateTime.Now.Equals(null), Is.False);

NUnit Integration

The challenges of implementing a generic test for the equality operators have now been outlined. Several paths of action are possible to implement the solution with NUnit. One way is to inherit test fixtures from a base class which will have factorized the assertions for equality operators. Another way consists in extending NUnit by creating a new type of constraint. This constraint evaluates whether or not two instances expected to be equal follow the semantics of the equality operators.

In the implementation presented in this article, I have chosen to create a NUnit constraint called EqualityOperatorConstraint. The code is available from my Subversion directory. Please refer to the instruction to download the tarballs.

Equality Operator Constraint

Let's review the details of the implementation of EqualityOperatorConstraint. We will first tackle on how equality operators can be resolved not at compile-time but at run-time.

IStaticEqualityOperatorProvider

The interface IStaticEqualityOperatorProvider is used to resolve the static equality operators at run-time. This interface defines two methods. As their names suggest, EvaluateStaticEqualEqualOperator and EvaluateStaticNotEqualOperator return the result for the expressions lhs == rhs and lhs != rhs, respectively.

public interface IStaticEqualityOperatorProvider
{
       bool EvaluateStaticEqualEqualOperator(object lhs, object rhs);
       bool EvaluateStaticNotEqualOperator(object lhs, object rhs);        
}

Several implementations are provided:

ReflectiveStaticEqualityOperatorProvider<T> relies on reflection to call the correct operator== and operator!= functions.

private bool? InvokeStaticOperator(T lhs, T rhs, string methodName)
{
    MethodInfo mi = typeof(T).GetMethod(methodName, BindingFlags.Static | BindingFlags.Public, null, new Type[] {
            typeof(T),
            typeof(T)},
       null);
 
    if (mi != null)
    {
        object result = mi.Invoke(null, new object[] { lhs, rhs });
        if (!(result is bool))
        {
            throw new InvalidCastException();
        }
        return (bool)result;
    }
    else
    {
        return null;
    }
}
 
public override bool EvaluateStaticEqualEqualOperator(T lhs, T rhs)
{
    bool? result = InvokeStaticOperator(lhs, rhs, "op_Equality");
    if (result == null)
    {
        throw new ReflectiveStaticEqualEqualOperatorNotFound(string.Format("operator== is not defined in \"{0}\"", typeof(T).Name));
    }
    else
    {
        return result.Value;
    }
}

DelegatedStaticEqualityOperatorProvider accepts delegates as parameters of the constructor. It allows to come up with an inline implementation of the provider using anonymous methods. The following piece of code create a provider for DateTime:

IStaticEqualityOperatorProvider provider = new DelegatedStaticEqualityOperatorProvider<DateTime>(
    delegate(DateTime lhs, DateTime rhs)
    {
       return lhs == rhs;
    },
    delegate(DateTime lhs, DateTime rhs)
    {
      return lhs != rhs;
    });

Aggregate of Atomic Constraints

Creating a new constraint in NUnit consists in implementing two methods of the abstract class Constraint: bool Matches(object actual) and void WriteDescriptionTo(MessageWriter writer). In the current implementation, EqualityOperatorConstraint constructs a compound constraint using & (with AndConstraint) and | (with OrConstraint) operators to add all the atomic constraints testing the semantic of the equality operators and the behavior of the Equals and GetHashCode methods.

Using the Equality Constraints

Let's go back to our first example with the Customer class. Testing the equality operators as well as testing Equals and GetHashCode is just a matter of using the new EqualityOperatorConstraint combined with ReflectiveStaticEqualityOperatorProvider<Customer>. The constraints comes with two flavors:

EqualityOperatorConstraint evaluates if two references are expected to be equal.
InequalityOperatorConstraint evaluates if two reference are expected to be unequal.

[Test]
public void TestCustomerWithEquality()
{
    Customer customer = new Customer("James");
    Constraint constraint = new EqualityOperatorConstraint(customer, new ReflectiveStaticEqualityOperatorProvider<Customer>());
 
    Assert.That(new Customer("James"), constraint);        
}
 
[Test]
public void TestCustomerWithInequality()
{
    Customer customer = new Customer("James");
    Constraint constraint = new InequalityOperatorConstraint(customer, new ReflectiveStaticEqualityOperatorProvider<Customer>());
 
    Assert.That(new Customer("David"), constraint);
}

The NUnit model provides a description when a constraint fails. As mentioned previously, the EqualityOperatorConstraint is an aggregate of simple constraints. To avoid any verbose message, the description of the first constraint which fails is provided instead. Consider the following case where the equality operator of the Customer class has been improperly implemented. Instead of comparing the names, the operator compares the length of the names.

class Customer
{
    private readonly string name;
 
    public Customer(string name)
    {
        this.name = name;
    }
 
    public string Name
    {
 
        get
        {
            return name;
        }
    }
 
 
    public override bool Equals(object obj)
    {
        Customer customer = obj as Customer;
        if (customer != null)
        {
            return this == customer;
        }
        else
        {
            return false;
        }
    }
 
    public override int GetHashCode()
    {
        return name.GetHashCode();
    }
 
    // Incorrect implementation of Customer. The lengths of the names are compared!
    public static bool operator ==(Customer lhs, Customer rhs)
    {
        if (object.ReferenceEquals(lhs, rhs))
        {
            return true;
        }
        else if ((object)lhs == null || (object)rhs == null)
        {
            return false;
        }
        else
        {
            return lhs.Name.Length == rhs.Name.Length;
        }
    }
 
    public static bool operator !=(Customer lhs, Customer rhs)
    {
        return !(lhs == rhs);
    }
 
    public override string ToString()
    {
        return Name;
    }
}

The case testing the inequality between a customer called James and Williams will pass since the names are of different lengths. However, testing the inequality between James and Henry will fail with this error message:

Assert.That(new Customer("Henry"), new InequalityOperatorConstraint(new Customer("James"),
                    new ReflectiveStaticEqualityOperatorProvider<Customer>()));

failed: operator ==(actual, expected) where "actual" was "Henry" and "expected" was "James"
Expected: False
Actual: True

A related test with the equality constraint this time will also fail because two customers with names of same length return a different hash code:

Assert.That(new Customer("Henry"), new EqualityOperatorConstraint(new Customer("James"),
                   new ReflectiveStaticEqualityOperatorProvider<Customer>()));

failed: actual.GetHashCode() == expected.GetHashCode() where "actual" was "Henry" and "expected" was "James"
Expected: True
Actual: False

Conclusion

In order to fully cover the tested code, the EqualityOperatorConstraint and the InequalityOperatorConstraint need to be used with different pairs of instances expected to be equal and unequal, respectivelly. The equality constraints can only carry out tests with the provided instances. So, as usual, keep an eye on code coverage while writing unit tests.

Pierre Rebours's Log - Thoughts on Engineered Software

Coalesce in SAS

Published in:

Coalesce in a data step

coalescec in a data-step

coalesce in a data-step

Coalescing in a SQL-Step

coalescec in SQL

coalesce in SQL

Type Conversion

Mixing Types in a data-step

Mixing types in SQL

Summary

Slide Number in PowerPoint

Published in:

Configuring the Master Slides

Configuring the Slides

Formatting scaled numbers

Published in:

MWSnap Review

Published in:

Order returned by GetMethods

Published in:

Returned Index vs. Ordered Index

Solutions

MetaData Token

Visual Studio Automation

ICorDebug

Implementation

CanShrink and CanGrow Behaviors

Published in:

Rendering Extensions

Conclusions

Load Testing using The Grinder

Published in:

Configuration

Property File

Load Test Specification

Conclusion

Context Connection and SQLCLR Functions

Published in:

Review of SQL Server 2005 Reporting Services, Essential Skills for Database Professionals

Published in:

Part 1, Getting Started

Part 2, Report Authoring

Part 3, Report Serving

Annexes

Testing Equality Operators with NUnit

Published in:

Semantics of the Equality Operators

Challenges of Testing

But Equality Operators are Resolved during Compilation

Value and Reference Types

NUnit Integration

Equality Operator Constraint

IStaticEqualityOperatorProvider

Aggregate of Atomic Constraints

Using the Equality Constraints

Conclusion

`coalescec` in a data-step

`coalesce` in a data-step

`coalescec` in SQL

`coalesce` in SQL