private static void WriteQualityValue(IQualityGate qualityGate, int VALUE_MAX_LENGTH)
        {
            Debug.Assert(qualityGate != null);
            double?valueNullable = qualityGate.Value;
            string valueString   = "null";

            if (valueNullable != null)
            {
                valueString = valueNullable.Value.ToString();
            }
            valueString = TruncateIfNeeded(valueString, VALUE_MAX_LENGTH);
            SetValueColors();
            WriteAlignedRight(valueString, VALUE_MAX_LENGTH);
            SetRegularColors();
        }
        private static void WriteQualityGateDetails(IQualityGate qualityGate, IQualityGate qualityGateBaseline)
        {
            Debug.Assert(qualityGate != null);
            // qualityGateBaseline can be null in case the qualityGate relies on diff!

            const int    QUALITY_GATE_NAME_MAX_LENGTH = 32;
            const int    PADDING          = 4;
            const int    STATUS_LENGTH    = 4; // Fail Warn Pass
            const int    VALUE_MAX_LENGTH = 7;
            const int    UNIT_MAX_LENGTH  = 10;
            const string FROM             = "from ";
            const string TO = " to ";

            int xPos = 0;

            //
            // Write quality gate name
            var name = TruncateIfNeeded(qualityGate.Name, QUALITY_GATE_NAME_MAX_LENGTH);

            SetRegularColors();
            Console.Write(name);
            xPos += QUALITY_GATE_NAME_MAX_LENGTH + PADDING;
            AlignToColumn(xPos);

            //
            // Write Status from .. to
            if (qualityGateBaseline != null)
            {
                Console.Write(FROM);
                WriteQualityGateStatus(qualityGateBaseline.Status);
                Console.Write(TO);
            }
            xPos += FROM.Length + STATUS_LENGTH + TO.Length;
            AlignToColumn(xPos);
            WriteQualityGateStatus(qualityGate.Status);
            xPos += STATUS_LENGTH + PADDING;
            AlignToColumn(xPos);

            //
            // Write Value from .. to
            if (qualityGateBaseline != null)
            {
                Console.Write(FROM);
                WriteQualityValue(qualityGateBaseline, VALUE_MAX_LENGTH);
                Console.Write(TO);
            }
            xPos += FROM.Length + VALUE_MAX_LENGTH + TO.Length;
            AlignToColumn(xPos);
            WriteQualityValue(qualityGate, VALUE_MAX_LENGTH);
            xPos += VALUE_MAX_LENGTH + 1;
            AlignToColumn(xPos);

            //
            // Write Unit
            string unit = TruncateIfNeeded(qualityGate.Unit, UNIT_MAX_LENGTH);

            SetValueColors();
            WriteAlignedLeft(unit, UNIT_MAX_LENGTH);
            SetRegularColors();
            xPos += UNIT_MAX_LENGTH + PADDING;
            AlignToColumn(xPos);


            // Write Getting Better / Worst
            if (qualityGateBaseline != null && qualityGate.Value != null && qualityGateBaseline.Value != null)
            {
                var newVal     = qualityGate.Value.Value;
                var oldVal     = qualityGateBaseline.Value.Value;
                var increasing = newVal > oldVal;
                var decreasing = newVal < oldVal;
                var moreIsBad  = qualityGate.MoreIsBad;
                if ((moreIsBad && increasing) || (!moreIsBad && decreasing))
                {
                    SetValueRedColors();
                    Console.Write("Getting Worst");
                }
                else if ((moreIsBad && decreasing) || (!moreIsBad && increasing))
                {
                    SetValueGreenColors();
                    Console.Write("Getting Better");
                }
            }


            Console.WriteLine();
        }