text:
/*!
 * \file
 * \brief SSBO layout tests.
 *//*--------------------------------------------------------------------*/

#include "es31fSSBOLayoutTests.hpp"
#include "es31fSSBOLayoutCase.hpp"
#include "tcuCommandLine.hpp"
#include "deRandom.hpp"
#include "deStringUtil.hpp"
#include "deString.h"

using std::string;
using std::vector;

namespace deqp
{
namespace gles31
{
namespace Functional
{

using namespace bb;
using glu::VarType;
using glu::StructType;

namespace
{

enum FeatureBits
{
	FEATURE_VECTORS				= (1<<0),
	FEATURE_MATRICES			= (1<<1),
	FEATURE_ARRAYS				= (1<<2),
	FEATURE_STRUCTS				= (1<<3),
	FEATURE_NESTED_STRUCTS		= (1<<4),
	FEATURE_INSTANCE_ARRAYS		= (1<<5),
	FEATURE_UNUSED_VARS			= (1<<6),
	FEATURE_UNUSED_MEMBERS		= (1<<7),
	FEATURE_PACKED_LAYOUT		= (1<<8),
	FEATURE_SHARED_LAYOUT		= (1<<9),
	FEATURE_STD140_LAYOUT		= (1<<10),
	FEATURE_STD430_LAYOUT		= (1<<11),
	FEATURE_MATRIX_LAYOUT		= (1<<12),	//!< Matrix layout flags.
	FEATURE_UNSIZED_ARRAYS		= (1<<13),
	FEATURE_ARRAYS_OF_ARRAYS	= (1<<14)
};

class RandomSSBOLayoutCase : public SSBOLayoutCase
{
public:

							RandomSSBOLayoutCase		(Context& context, const char* name, const char* description, BufferMode bufferMode, deUint32 features, deUint32 seed);

	void					init						(void);

private:
	void					generateBlock				(de::Random& rnd, deUint32 layoutFlags);
	void					generateBufferVar			(de::Random& rnd, BufferBlock& block, bool isLastMember);
	glu::VarType			generateType				(de::Random& rnd, int structDepth, int arrayDepth, bool arrayOk, bool unusedArrayOk);

	deUint32				m_features;
	int						m_maxBlocks;
	int						m_maxInstances;
	int						m_maxArrayLength;
	int						m_maxArrayDepth;
	int						m_maxStructDepth;
	int						m_maxBlockMembers;
	int						m_maxStructMembers;
	deUint32				m_seed;

	int						m_blockNdx;
	int						m_bufferVarNdx;
	int						m_structNdx;
};

RandomSSBOLayoutCase::RandomSSBOLayoutCase (Context& context, const char* name, const char* description, BufferMode bufferMode, deUint32 features, deUint32 seed)
	: SSBOLayoutCase		(context.getTestContext(), context.getRenderContext(), name, description, glu::GLSL_VERSION_310_ES, bufferMode)
	, m_features			(features)
	, m_maxBlocks			(3)
	, m_maxInstances		((features & FEATURE_INSTANCE_ARRAYS)	? 3 : 0)
	, m_maxArrayLength		((features & FEATURE_ARRAYS)			? 8 : 0)
	, m_maxArrayDepth		((features & FEATURE_ARRAYS_OF_ARRAYS)	? 2 : 0)
	, m_maxStructDepth		((features & FEATURE_STRUCTS)			? 2 : 0)
	, m_maxBlockMembers		(4)
	, m_maxStructMembers	(4)
	, m_seed				(seed)
	, m_blockNdx			(1)
	, m_bufferVarNdx		(1)
	, m_structNdx			(1)
{
}

void RandomSSBOLayoutCase::init (void)
{
	de::Random rnd(m_seed);

	const int numBlocks = rnd.getInt(1, m_maxBlocks);

	for (int ndx = 0; ndx < numBlocks; ndx++)
		generateBlock(rnd, 0);
}

void RandomSSBOLayoutCase::generateBlock (de::Random& rnd, deUint32 layoutFlags)
{
	DE_ASSERT(m_blockNdx <= 'z' - 'a');

	const float		instanceArrayWeight	= 0.3f;
	BufferBlock&	block				= m_interface.allocBlock((string("Block") + (char)('A' + m_blockNdx)).c_str());
	int				numInstances		= (m_maxInstances > 0 && rnd.getFloat() < instanceArrayWeight) ? rnd.getInt(0, m_maxInstances) : 0;
	int				numVars				= rnd.getInt(1, m_maxBlockMembers);

	if (numInstances > 0)
		block.setArraySize(numInstances);

	if (numInstances > 0 || rnd.getBool())
		block.setInstanceName((string("block") + (char)('A' + m_blockNdx)).c_str());

	// Layout flag candidates.
	vector<deUint32> layoutFlagCandidates;
	layoutFlagCandidates.push_back(0);
	if (m_features & FEATURE_PACKED_LAYOUT)
		layoutFlagCandidates.push_back(LAYOUT_PACKED);
	if ((m_features & FEATURE_SHARED_LAYOUT))
		layoutFlagCandidates.push_back(LAYOUT_SHARED);
	if (m_features & FEATURE_STD140_LAYOUT)
		layoutFlagCandidates.push_back(LAYOUT_STD140);

	layoutFlags |= rnd.choose<deUint32>(layoutFlagCandidates.begin(), layoutFlagCandidates.end());

	if (m_features & FEATURE_MATRIX_LAYOUT)
	{
		static const deUint32 matrixCandidates[] = { 0, LAYOUT_ROW_MAJOR, LAYOUT_COLUMN_MAJOR };
		layoutFlags |= rnd.choose<deUint32>(&matrixCandidates[0], &matrixCandidates[DE_LENGTH_OF_ARRAY(matrixCandidates)]);
	}

	block.setFlags(layoutFlags);

	for (int ndx = 0; ndx < numVars; ndx++)
		generateBufferVar(rnd, block, (ndx+1 == numVars));

	if (numVars > 0)
	{
		const BufferVar&	lastVar			= *(block.end()-1);
		const glu::VarType&	lastType		= lastVar.getType();
		const bool			isUnsizedArr	= lastType.isArrayType() && (lastType.getArraySize() == glu::VarType::UNSIZED_ARRAY);

		if (isUnsizedArr)
		{
			for (int instanceNdx = 0; instanceNdx < (numInstances ? numInstances : 1); instanceNdx++)
			{
				const int arrSize = rnd.getInt(0, m_maxArrayLength);
				block.setLastUnsizedArraySize(instanceNdx, arrSize);
			}
		}
	}

	m_blockNdx += 1;
}

static std::string genName (char first, char last, int ndx)
{
	std::string	str			= "";
	int			alphabetLen	= last - first + 1;

	while (ndx > alphabetLen)
	{
		str.insert(str.begin(), (char)(first + ((ndx-1)%alphabetLen)));
		ndx = ((ndx-1) / alphabetLen);
	}

	str.insert(str.begin(), (char)(first + (ndx%(alphabetLen+1)) - 1));

	return str;
}

void RandomSSBOLayoutCase::generateBufferVar (de::Random& rnd, BufferBlock& block, bool isLastMember)
{
	const float			readWeight			= 0.7f;
	const float			writeWeight			= 0.7f;
	const float			accessWeight		= 0.85f;
	const bool			unusedOk			= (m_features & FEATURE_UNUSED_VARS) != 0;
	const std::string	name				= genName('a', 'z', m_bufferVarNdx);
	const glu::VarType	type				= generateType(rnd, 0, 0, true, isLastMember && (m_features & FEATURE_UNSIZED_ARRAYS));
	const bool			access				= !unusedOk || (rnd.getFloat() < accessWeight);
	const bool			read				= access ? (rnd.getFloat() < readWeight) : false;
	const bool			write				= access ? (!read || (rnd.getFloat() < writeWeight)) : false;
	const deUint32		flags				= (read ? ACCESS_READ : 0) | (write ? ACCESS_WRITE : 0);

	block.addMember(BufferVar(name.c_str(), type, flags));

	m_bufferVarNdx += 1;
}

glu::VarType RandomSSBOLayoutCase::generateType (de::Random& rnd, int structDepth, int arrayDepth, bool arrayOk, bool unsizedArrayOk)
{
	const float structWeight		= 0.1f;
	const float arrayWeight			= 0.1f;
	const float	unsizedArrayWeight	= 0.8f;

	DE_ASSERT(arrayOk || !unsizedArrayOk);

	if (unsizedArrayOk && (rnd.getFloat() < unsizedArrayWeight))
	{
		const bool			childArrayOk	= ((m_features & FEATURE_ARRAYS_OF_ARRAYS) != 0) &&
											  (arrayDepth < m_maxArrayDepth);
		const glu::VarType	elementType		= generateType(rnd, structDepth, arrayDepth+1, childArrayOk, false);
		return glu::VarType(elementType, glu::VarType::UNSIZED_ARRAY);
	}
	else if (structDepth < m_maxStructDepth && rnd.getFloat() < structWeight)
	{
		// \todo [2013-10-14 pyry] Implement unused flags for members!
//		bool					unusedOk			= (m_features & FEATURE_UNUSED_MEMBERS) != 0;
		vector<glu::VarType>	memberTypes;
		int						numMembers = rnd.getInt(1, m_maxStructMembers);

		// Generate members first so nested struct declarations are in correct order.
		for (int ndx = 0; ndx < numMembers; ndx++)
			memberTypes.push_back(generateType(rnd, structDepth+1, arrayDepth, (arrayDepth < m_maxArrayDepth), false));

		glu::StructType& structType = m_interface.allocStruct((string("s") + genName('A', 'Z', m_structNdx)).c_str());
		m_structNdx += 1;

		DE_ASSERT(numMembers <= 'Z' - 'A');
		for (int ndx = 0; ndx < numMembers; ndx++)
		{
			structType.addMember((string("m") + (char)('A' + ndx)).c_str(), memberTypes[ndx]);
		}

		return glu::VarType(&structType);
	}
	else if (m_maxArrayLength > 0 && arrayOk && rnd.getFloat() < arrayWeight)
	{
		const int			arrayLength		= rnd.getInt(1, m_maxArrayLength);
		const bool			childArrayOk	= ((m_features & FEATURE_ARRAYS_OF_ARRAYS) != 0) &&
											  (arrayDepth < m_maxArrayDepth);
		const glu::VarType	elementType		= generateType(rnd, structDepth, arrayDepth+1, childArrayOk, false);

		return glu::VarType(elementType, arrayLength);
	}
	else
	{
		vector<glu::DataType> typeCandidates;

		typeCandidates.push_back(glu::TYPE_FLOAT);
		typeCandidates.push_back(glu::TYPE_INT);
		typeCandidates.push_back(glu::TYPE_UINT);
		typeCandidates.push_back(glu::TYPE_BOOL);

		if (m_features & FEATURE_VECTORS)
		{
			typeCandidates.push_back(glu::TYPE_FLOAT_VEC2);
			typeCandidates.push_back(glu::TYPE_FLOAT_VEC3);
			typeCandidates.push_back(glu::TYPE_FLOAT_VEC4);
			typeCandidates.push_back(glu::TYPE_INT_VEC2);
			typeCandidates.push_back(glu::TYPE_INT_VEC3);
			typeCandidates.push_back(glu::TYPE_INT_VEC4);
			typeCandidates.push_back(glu::TYPE_UINT_VEC2);
			typeCandidates.push_back(glu::TYPE_UINT_VEC3);
			typeCandidates.push_back(glu::TYPE_UINT_VEC4);
			typeCandidates.push_back(glu::TYPE_BOOL_VEC2);
			typeCandidates.push_back(glu::TYPE_BOOL_VEC3);
			typeCandidates.push_back(glu::TYPE_BOOL_VEC4);
		}

		if (m_features & FEATURE_MATRICES)
		{
			typeCandidates.push_back(glu::TYPE_FLOAT_MAT2);
			typeCandidates.push_back(glu::TYPE_FLOAT_MAT2X3);
			typeCandidates.push_back(glu::TYPE_FLOAT_MAT3X2);
			typeCandidates.push_back(glu::TYPE_FLOAT_MAT3);
			typeCandidates.push_back(glu::TYPE_FLOAT_MAT3X4);
			typeCandidates.push_back(glu::TYPE_FLOAT_MAT4X2);
			typeCandidates.push_back(glu::TYPE_FLOAT_MAT4X3);
			typeCandidates.push_back(glu::TYPE_FLOAT_MAT4);
		}

		glu::DataType	type		= rnd.choose<glu::DataType>(typeCandidates.begin(), typeCandidates.end());
		glu::Precision	precision;

		if (!glu::isDataTypeBoolOrBVec(type))
		{
			// Precision.
			static const glu::Precision precisionCandidates[] = { glu::PRECISION_LOWP, glu::PRECISION_MEDIUMP, glu::PRECISION_HIGHP };
			precision = rnd.choose<glu::Precision>(&precisionCandidates[0], &precisionCandidates[DE_LENGTH_OF_ARRAY(precisionCandidates)]);
		}
		else
			precision = glu::PRECISION_LAST;

		return glu::VarType(type, precision);
	}
}

class BlockBasicTypeCase : public SSBOLayoutCase
{
public:
	BlockBasicTypeCase (Context& context, const char* name, const char* description, const VarType& type, deUint32 layoutFlags, int numInstances)
		: SSBOLayoutCase(context.getTestContext(), context.getRenderContext(), name, description, glu::GLSL_VERSION_310_ES, BUFFERMODE_PER_BLOCK)
	{
		BufferBlock& block = m_interface.allocBlock("Block");
		block.addMember(BufferVar("var", type, ACCESS_READ|ACCESS_WRITE));
		block.setFlags(layoutFlags);

		if (numInstances > 0)
		{
			block.setArraySize(numInstances);
			block.setInstanceName("block");
		}
	}
};

class BlockBasicUnsizedArrayCase : public SSBOLayoutCase
{
public:
	BlockBasicUnsizedArrayCase (Context& context, const char* name, const char* description, const VarType& elementType, int arraySize, deUint32 layoutFlags)
		: SSBOLayoutCase(context.getTestContext(), context.getRenderContext(), name, description, glu::GLSL_VERSION_310_ES, BUFFERMODE_PER_BLOCK)
	{
		BufferBlock& block = m_interface.allocBlock("Block");
		block.addMember(BufferVar("var", VarType(elementType, VarType::UNSIZED_ARRAY), ACCESS_READ|ACCESS_WRITE));
		block.setFlags(layoutFlags);

		block.setLastUnsizedArraySize(0, arraySize);
	}
};

static void createRandomCaseGroup (tcu::TestCaseGroup* parentGroup, Context& context, const char* groupName, const char* description, SSBOLayoutCase::BufferMode bufferMode, deUint32 features, int numCases, deUint32 baseSeed)
{
	tcu::TestCaseGroup* group = new tcu::TestCaseGroup(context.getTestContext(), groupName, description);
	parentGroup->addChild(group);

	baseSeed += (deUint32)context.getTestContext().getCommandLine().getBaseSeed();

	for (int ndx = 0; ndx < numCases; ndx++)
		group->addChild(new RandomSSBOLayoutCase(context, de::toString(ndx).c_str(), "", bufferMode, features, (deUint32)ndx+baseSeed));
}

class BlockSingleStructCase : public SSBOLayoutCase
{
public:
	BlockSingleStructCase (Context& context, const char* name, const char* description, deUint32 layoutFlags, BufferMode bufferMode, int numInstances)
		: SSBOLayoutCase	(context.getTestContext(), context.getRenderContext(), name, description, glu::GLSL_VERSION_310_ES, bufferMode)
		, m_layoutFlags		(layoutFlags)
		, m_numInstances	(numInstances)
	{
	}

	void init (void)
	{
		StructType& typeS = m_interface.allocStruct("S");
		typeS.addMember("a", VarType(glu::TYPE_INT_VEC3, glu::PRECISION_HIGHP)); // \todo [pyry] First member is unused.
		typeS.addMember("b", VarType(VarType(glu::TYPE_FLOAT_MAT3, glu::PRECISION_MEDIUMP), 4));
		typeS.addMember("c", VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP));

		BufferBlock& block = m_interface.allocBlock("Block");
		block.addMember(BufferVar("s", VarType(&typeS), ACCESS_READ|ACCESS_WRITE));
		block.setFlags(m_layoutFlags);

		if (m_numInstances > 0)
		{
			block.setInstanceName("block");
			block.setArraySize(m_numInstances);
		}
	}

private:
	deUint32	m_layoutFlags;
	int			m_numInstances;
};

class BlockSingleStructArrayCase : public SSBOLayoutCase
{
public:
	BlockSingleStructArrayCase (Context& context, const char* name, const char* description, deUint32 layoutFlags, BufferMode bufferMode, int numInstances)
		: SSBOLayoutCase	(context.getTestContext(), context.getRenderContext(), name, description, glu::GLSL_VERSION_310_ES, bufferMode)
		, m_layoutFlags		(layoutFlags)
		, m_numInstances	(numInstances)
	{
	}

	void init (void)
	{
		StructType& typeS = m_interface.allocStruct("S");
		typeS.addMember("a", VarType(glu::TYPE_INT_VEC3, glu::PRECISION_HIGHP)); // \todo [pyry] UNUSED
		typeS.addMember("b", VarType(VarType(glu::TYPE_FLOAT_MAT3, glu::PRECISION_MEDIUMP), 4));
		typeS.addMember("c", VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP));

		BufferBlock& block = m_interface.allocBlock("Block");
		block.addMember(BufferVar("u", VarType(glu::TYPE_UINT, glu::PRECISION_LOWP), 0 /* no access */));
		block.addMember(BufferVar("s", VarType(VarType(&typeS), 3), ACCESS_READ|ACCESS_WRITE));
		block.addMember(BufferVar("v", VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_MEDIUMP), ACCESS_WRITE));
		block.setFlags(m_layoutFlags);

		if (m_numInstances > 0)
		{
			block.setInstanceName("block");
			block.setArraySize(m_numInstances);
		}
	}

private:
	deUint32	m_layoutFlags;
	int			m_numInstances;
};

class BlockSingleNestedStructCase : public SSBOLayoutCase
{
public:
	BlockSingleNestedStructCase (Context& context, const char* name, const char* description, deUint32 layoutFlags, BufferMode bufferMode, int numInstances)
		: SSBOLayoutCase	(context.getTestContext(), context.getRenderContext(), name, description, glu::GLSL_VERSION_310_ES, bufferMode)
		, m_layoutFlags		(layoutFlags)
		, m_numInstances	(numInstances)
	{
	}

	void init (void)
	{
		StructType& typeS = m_interface.allocStruct("S");
		typeS.addMember("a", VarType(glu::TYPE_INT_VEC3, glu::PRECISION_HIGHP));
		typeS.addMember("b", VarType(VarType(glu::TYPE_FLOAT_MAT3, glu::PRECISION_MEDIUMP), 4));
		typeS.addMember("c", VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP)); // \todo [pyry] UNUSED

		StructType& typeT = m_interface.allocStruct("T");
		typeT.addMember("a", VarType(glu::TYPE_FLOAT_MAT3, glu::PRECISION_MEDIUMP));
		typeT.addMember("b", VarType(&typeS));

		BufferBlock& block = m_interface.allocBlock("Block");
		block.addMember(BufferVar("s", VarType(&typeS), ACCESS_READ));
		block.addMember(BufferVar("v", VarType(glu::TYPE_FLOAT_VEC2, glu::PRECISION_LOWP), 0 /* no access */));
		block.addMember(BufferVar("t", VarType(&typeT), ACCESS_READ|ACCESS_WRITE));
		block.addMember(BufferVar("u", VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP), ACCESS_WRITE));
		block.setFlags(m_layoutFlags);

		if (m_numInstances > 0)
		{
			block.setInstanceName("block");
			block.setArraySize(m_numInstances);
		}
	}

private:
	deUint32	m_layoutFlags;
	int			m_numInstances;
};

class BlockSingleNestedStructArrayCase : public SSBOLayoutCase
{
public:
	BlockSingleNestedStructArrayCase (Context& context, const char* name, const char* description, deUint32 layoutFlags, BufferMode bufferMode, int numInstances)
		: SSBOLayoutCase	(context.getTestContext(), context.getRenderContext(), name, description, glu::GLSL_VERSION_310_ES, bufferMode)
		, m_layoutFlags		(layoutFlags)
		, m_numInstances	(numInstances)
	{
	}

	void init (void)
	{
		StructType& typeS = m_interface.allocStruct("S");
		typeS.addMember("a", VarType(glu::TYPE_INT_VEC3, glu::PRECISION_HIGHP));
		typeS.addMember("b", VarType(VarType(glu::TYPE_INT_VEC2, glu::PRECISION_MEDIUMP), 4));
		typeS.addMember("c", VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP)); // \todo [pyry] UNUSED

		StructType& typeT = m_interface.allocStruct("T");
		typeT.addMember("a", VarType(glu::TYPE_FLOAT_MAT3, glu::PRECISION_MEDIUMP));
		typeT.addMember("b", VarType(VarType(&typeS), 3));

		BufferBlock& block = m_interface.allocBlock("Block");
		block.addMember(BufferVar("s", VarType(&typeS), ACCESS_WRITE));
		block.addMember(BufferVar("v", VarType(glu::TYPE_FLOAT_VEC2, glu::PRECISION_LOWP), 0 /* no access */));
		block.addMember(BufferVar("t", VarType(VarType(&typeT), 2), ACCESS_READ));
		block.addMember(BufferVar("u", VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP), ACCESS_READ|ACCESS_WRITE));
		block.setFlags(m_layoutFlags);

		if (m_numInstances > 0)
		{
			block.setInstanceName("block");
			block.setArraySize(m_numInstances);
		}
	}

private:
	deUint32	m_layoutFlags;
	int			m_numInstances;
};

class BlockUnsizedStructArrayCase : public SSBOLayoutCase
{
public:
	BlockUnsizedStructArrayCase (Context& context, const char* name, const char* description, deUint32 layoutFlags, BufferMode bufferMode, int numInstances)
		: SSBOLayoutCase	(context.getTestContext(), context.getRenderContext(), name, description, glu::GLSL_VERSION_310_ES, bufferMode)
		, m_layoutFlags		(layoutFlags)
		, m_numInstances	(numInstances)
	{
	}

	void init (void)
	{
		StructType& typeS = m_interface.allocStruct("S");
		typeS.addMember("a", VarType(glu::TYPE_UINT_VEC2, glu::PRECISION_HIGHP)); // \todo [pyry] UNUSED
		typeS.addMember("b", VarType(VarType(glu::TYPE_FLOAT_MAT2X4, glu::PRECISION_MEDIUMP), 4));
		typeS.addMember("c", VarType(glu::TYPE_FLOAT_VEC3, glu::PRECISION_HIGHP));

		BufferBlock& block = m_interface.allocBlock("Block");
		block.addMember(BufferVar("u", VarType(glu::TYPE_FLOAT_VEC2, glu::PRECISION_LOWP), 0 /* no access */));
		block.addMember(BufferVar("v", VarType(glu::TYPE_UINT, glu::PRECISION_MEDIUMP), ACCESS_WRITE));
		block.addMember(BufferVar("s", VarType(VarType(&typeS), VarType::UNSIZED_ARRAY), ACCESS_READ|ACCESS_WRITE));
		block.setFlags(m_layoutFlags);

		if (m_numInstances > 0)
		{
			block.setInstanceName("block");
			block.setArraySize(m_numInstances);
		}

		{
			de::Random rnd(246);
			for (int ndx = 0; ndx < (m_numInstances ? m_numInstances : 1); ndx++)
			{
				const int lastArrayLen = rnd.getInt(1, 5);
				block.setLastUnsizedArraySize(ndx, lastArrayLen);
			}
		}
	}

private:
	deUint32	m_layoutFlags;
	int			m_numInstances;
};

class Block2LevelUnsizedStructArrayCase : public SSBOLayoutCase
{
public:
	Block2LevelUnsizedStructArrayCase (Context& context, const char* name, const char* description, deUint32 layoutFlags, BufferMode bufferMode, int numInstances)
		: SSBOLayoutCase	(context.getTestContext(), context.getRenderContext(), name, description, glu::GLSL_VERSION_310_ES, bufferMode)
		, m_layoutFlags		(layoutFlags)
		, m_numInstances	(numInstances)
	{
	}

	void init (void)
	{
		StructType& typeS = m_interface.allocStruct("S");
		typeS.addMember("a", VarType(glu::TYPE_INT_VEC3, glu::PRECISION_HIGHP));
		typeS.addMember("c", VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP));

		BufferBlock& block = m_interface.allocBlock("Block");
		block.addMember(BufferVar("u", VarType(glu::TYPE_UINT, glu::PRECISION_LOWP), 0 /* no access */));
		block.addMember(BufferVar("v", VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_MEDIUMP), ACCESS_WRITE));
		block.addMember(BufferVar("s", VarType(VarType(VarType(&typeS), 2), VarType::UNSIZED_ARRAY), ACCESS_READ|ACCESS_WRITE));
		block.setFlags(m_layoutFlags);

		if (m_numInstances > 0)
		{
			block.setInstanceName("block");
			block.setArraySize(m_numInstances);
		}

		{
			de::Random rnd(2344);
			for (int ndx = 0; ndx < (m_numInstances ? m_numInstances : 1); ndx++)
			{
				const int lastArrayLen = rnd.getInt(1, 5);
				block.setLastUnsizedArraySize(ndx, lastArrayLen);
			}
		}
	}

private:
	deUint32	m_layoutFlags;
	int			m_numInstances;
};

class BlockUnsizedNestedStructArrayCase : public SSBOLayoutCase
{
public:
	BlockUnsizedNestedStructArrayCase (Context& context, const char* name, const char* description, deUint32 layoutFlags, BufferMode bufferMode, int numInstances)
		: SSBOLayoutCase	(context.getTestContext(), context.getRenderContext(), name, description, glu::GLSL_VERSION_310_ES, bufferMode)
		, m_layoutFlags		(layoutFlags)
		, m_numInstances	(numInstances)
	{
	}

	void init (void)
	{
		StructType& typeS = m_interface.allocStruct("S");
		typeS.addMember("a", VarType(glu::TYPE_UINT_VEC3, glu::PRECISION_HIGHP));
		typeS.addMember("b", VarType(VarType(glu::TYPE_FLOAT_VEC2, glu::PRECISION_MEDIUMP), 4));
		typeS.addMember("c", VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP)); // \todo [pyry] UNUSED

		StructType& typeT = m_interface.allocStruct("T");
		typeT.addMember("a", VarType(glu::TYPE_FLOAT_MAT4X3, glu::PRECISION_MEDIUMP));
		typeT.addMember("b", VarType(VarType(&typeS), 3));
		typeT.addMember("c", VarType(glu::TYPE_INT, glu::PRECISION_HIGHP));

		BufferBlock& block = m_interface.allocBlock("Block");
		block.addMember(BufferVar("s", VarType(&typeS), ACCESS_WRITE));
		block.addMember(BufferVar("v", VarType(glu::TYPE_FLOAT_VEC2, glu::PRECISION_LOWP), 0 /* no access */));
		block.addMember(BufferVar("u", VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP), ACCESS_READ|ACCESS_WRITE));
		block.addMember(BufferVar("t", VarType(VarType(&typeT), VarType::UNSIZED_ARRAY), ACCESS_READ));
		block.setFlags(m_layoutFlags);

		if (m_numInstances > 0)
		{
			block.setInstanceName("block");
			block.setArraySize(m_numInstances);
		}

		{
			de::Random rnd(7921);
			for (int ndx = 0; ndx < (m_numInstances ? m_numInstances : 1); ndx++)
			{
				const int lastArrayLen = rnd.getInt(1, 5);
				block.setLastUnsizedArraySize(ndx, lastArrayLen);
			}
		}
	}

private:
	deUint32	m_layoutFlags;
	int			m_numInstances;
};

class BlockMultiBasicTypesCase : public SSBOLayoutCase
{
public:
	BlockMultiBasicTypesCase (Context& context, const char* name, const char* description, deUint32 flagsA, deUint32 flagsB, BufferMode bufferMode, int numInstances)
		: SSBOLayoutCase	(context.getTestContext(), context.getRenderContext(), name, description, glu::GLSL_VERSION_310_ES, bufferMode)
		, m_flagsA			(flagsA)
		, m_flagsB			(flagsB)
		, m_numInstances	(numInstances)
	{
	}

	void init (void)
	{
		BufferBlock& blockA = m_interface.allocBlock("BlockA");
		blockA.addMember(BufferVar("a", VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), ACCESS_READ|ACCESS_WRITE));
		blockA.addMember(BufferVar("b", VarType(glu::TYPE_UINT_VEC3, glu::PRECISION_LOWP), 0 /* no access */));
		blockA.addMember(BufferVar("c", VarType(glu::TYPE_FLOAT_MAT2, glu::PRECISION_MEDIUMP), ACCESS_READ));
		blockA.setInstanceName("blockA");
		blockA.setFlags(m_flagsA);

		BufferBlock& blockB = m_interface.allocBlock("BlockB");
		blockB.addMember(BufferVar("a", VarType(glu::TYPE_FLOAT_MAT3, glu::PRECISION_MEDIUMP), ACCESS_WRITE));
		blockB.addMember(BufferVar("b", VarType(glu::TYPE_INT_VEC2, glu::PRECISION_LOWP), ACCESS_READ));
		blockB.addMember(BufferVar("c", VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), 0 /* no access */));
		blockB.addMember(BufferVar("d", VarType(glu::TYPE_BOOL, glu::PRECISION_LAST), ACCESS_READ|ACCESS_WRITE));
		blockB.setInstanceName("blockB");
		blockB.setFlags(m_flagsB);

		if (m_numInstances > 0)
		{
			blockA.setArraySize(m_numInstances);
			blockB.setArraySize(m_numInstances);
		}
	}

private:
	deUint32	m_flagsA;
	deUint32	m_flagsB;
	int			m_numInstances;
};

class BlockMultiNestedStructCase : public SSBOLayoutCase
{
public:
	BlockMultiNestedStructCase (Context& context, const char* name, const char* description, deUint32 flagsA, deUint32 flagsB, BufferMode bufferMode, int numInstances)
		: SSBOLayoutCase	(context.getTestContext(), context.getRenderContext(), name, description, glu::GLSL_VERSION_310_ES, bufferMode)
		, m_flagsA			(flagsA)
		, m_flagsB			(flagsB)
		, m_numInstances	(numInstances)
	{
	}

	void init (void)
	{
		StructType& typeS = m_interface.allocStruct("S");
		typeS.addMember("a", VarType(glu::TYPE_FLOAT_MAT3, glu::PRECISION_LOWP));
		typeS.addMember("b", VarType(VarType(glu::TYPE_INT_VEC2, glu::PRECISION_MEDIUMP), 4));
		typeS.addMember("c", VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP));

		StructType& typeT = m_interface.allocStruct("T");
		typeT.addMember("a", VarType(glu::TYPE_UINT, glu::PRECISION_MEDIUMP)); // \todo [pyry] UNUSED
		typeT.addMember("b", VarType(&typeS));
		typeT.addMember("c", VarType(glu::TYPE_BOOL_VEC4, glu::PRECISION_LAST));

		BufferBlock& blockA = m_interface.allocBlock("BlockA");
		blockA.addMember(BufferVar("a", VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), ACCESS_READ|ACCESS_WRITE));
		blockA.addMember(BufferVar("b", VarType(&typeS), ACCESS_WRITE));
		blockA.addMember(BufferVar("c", VarType(glu::TYPE_UINT_VEC3, glu::PRECISION_LOWP), 0 /* no access */));
		blockA.setInstanceName("blockA");
		blockA.setFlags(m_flagsA);

		BufferBlock& blockB = m_interface.allocBlock("BlockB");
		blockB.addMember(BufferVar("a", VarType(glu::TYPE_FLOAT_MAT2, glu::PRECISION_MEDIUMP), ACCESS_WRITE));
		blockB.addMember(BufferVar("b", VarType(&typeT), ACCESS_READ|ACCESS_WRITE));
		blockB.addMember(BufferVar("c", VarType(glu::TYPE_BOOL_VEC4, glu::PRECISION_LAST), 0 /* no access */));
		blockB.addMember(BufferVar("d", VarType(glu::TYPE_BOOL, glu::PRECISION_LAST), ACCESS_READ|ACCESS_WRITE));
		blockB.setInstanceName("blockB");
		blockB.setFlags(m_flagsB);

		if (m_numInstances > 0)
		{
			blockA.setArraySize(m_numInstances);
			blockB.setArraySize(m_numInstances);
		}
	}

private:
	deUint32	m_flagsA;
	deUint32	m_flagsB;
	int			m_numInstances;
};

} // anonymous

SSBOLayoutTests::SSBOLayoutTests (Context& context)
	: TestCaseGroup(context, "layout", "SSBO Layout Tests")
{
}

SSBOLayoutTests::~SSBOLayoutTests (void)
{
}

void SSBOLayoutTests::init (void)
{
	static const glu::DataType basicTypes[] =
	{
		glu::TYPE_FLOAT,
		glu::TYPE_FLOAT_VEC2,
		glu::TYPE_FLOAT_VEC3,
		glu::TYPE_FLOAT_VEC4,
		glu::TYPE_INT,
		glu::TYPE_INT_VEC2,
		glu::TYPE_INT_VEC3,
		glu::TYPE_INT_VEC4,
		glu::TYPE_UINT,
		glu::TYPE_UINT_VEC2,
		glu::TYPE_UINT_VEC3,
		glu::TYPE_UINT_VEC4,
		glu::TYPE_BOOL,
		glu::TYPE_BOOL_VEC2,
		glu::TYPE_BOOL_VEC3,
		glu::TYPE_BOOL_VEC4,
		glu::TYPE_FLOAT_MAT2,
		glu::TYPE_FLOAT_MAT3,
		glu::TYPE_FLOAT_MAT4,
		glu::TYPE_FLOAT_MAT2X3,
		glu::TYPE_FLOAT_MAT2X4,
		glu::TYPE_FLOAT_MAT3X2,
		glu::TYPE_FLOAT_MAT3X4,
		glu::TYPE_FLOAT_MAT4X2,
		glu::TYPE_FLOAT_MAT4X3
	};

	static const struct
	{
		const char*		name;
		deUint32		flags;
	} layoutFlags[] =
	{
		{ "shared",		LAYOUT_SHARED	},
		{ "packed",		LAYOUT_PACKED	},
		{ "std140",		LAYOUT_STD140	},
		{ "std430",		LAYOUT_STD430	}
	};

	static const struct
	{
		const char*		name;
		deUint32		flags;
	} matrixFlags[] =
	{
		{ "row_major",		LAYOUT_ROW_MAJOR	},
		{ "column_major",	LAYOUT_COLUMN_MAJOR }
	};

	static const struct
	{
		const char*							name;
		SSBOLayoutCase::BufferMode		mode;
	} bufferModes[] =
	{
		{ "per_block_buffer",	SSBOLayoutCase::BUFFERMODE_PER_BLOCK },
		{ "single_buffer",		SSBOLayoutCase::BUFFERMODE_SINGLE	}
	};

	// ubo.single_basic_type
	{
		tcu::TestCaseGroup* singleBasicTypeGroup = new tcu::TestCaseGroup(m_testCtx, "single_basic_type", "Single basic variable in single buffer");
		addChild(singleBasicTypeGroup);

		for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
		{
			tcu::TestCaseGroup* layoutGroup = new tcu::TestCaseGroup(m_testCtx, layoutFlags[layoutFlagNdx].name, "");
			singleBasicTypeGroup->addChild(layoutGroup);

			for (int basicTypeNdx = 0; basicTypeNdx < DE_LENGTH_OF_ARRAY(basicTypes); basicTypeNdx++)
			{
				glu::DataType	type		= basicTypes[basicTypeNdx];
				const char*		typeName	= glu::getDataTypeName(type);

				if (glu::isDataTypeBoolOrBVec(type))
					layoutGroup->addChild(new BlockBasicTypeCase(m_context, typeName, "", VarType(type, glu::PRECISION_LAST), layoutFlags[layoutFlagNdx].flags, 0));
				else
				{
					for (int precNdx = 0; precNdx < glu::PRECISION_LAST; precNdx++)
					{
						const glu::Precision	precision	= glu::Precision(precNdx);
						const string			caseName	= string(glu::getPrecisionName(precision)) + "_" + typeName;

						layoutGroup->addChild(new BlockBasicTypeCase(m_context, caseName.c_str(), "", VarType(type, precision), layoutFlags[layoutFlagNdx].flags, 0));
					}
				}

				if (glu::isDataTypeMatrix(type))
				{
					for (int matFlagNdx = 0; matFlagNdx < DE_LENGTH_OF_ARRAY(matrixFlags); matFlagNdx++)
					{
						for (int precNdx = 0; precNdx < glu::PRECISION_LAST; precNdx++)
						{
							const glu::Precision	precision	= glu::Precision(precNdx);
							const string			caseName	= string(matrixFlags[matFlagNdx].name) + "_" + string(glu::getPrecisionName(precision)) + "_" + typeName;

							layoutGroup->addChild(new BlockBasicTypeCase(m_context, caseName.c_str(), "", glu::VarType(type, precision), layoutFlags[layoutFlagNdx].flags|matrixFlags[matFlagNdx].flags, 0));
						}
					}
				}
			}
		}
	}

	// ubo.single_basic_array
	{
		tcu::TestCaseGroup* singleBasicArrayGroup = new tcu::TestCaseGroup(m_testCtx, "single_basic_array", "Single basic array variable in single buffer");
		addChild(singleBasicArrayGroup);

		for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
		{
			tcu::TestCaseGroup* layoutGroup = new tcu::TestCaseGroup(m_testCtx, layoutFlags[layoutFlagNdx].name, "");
			singleBasicArrayGroup->addChild(layoutGroup);

			for (int basicTypeNdx = 0; basicTypeNdx < DE_LENGTH_OF_ARRAY(basicTypes); basicTypeNdx++)
			{
				glu::DataType	type		= basicTypes[basicTypeNdx];
				const char*		typeName	= glu::getDataTypeName(type);
				const int		arraySize	= 3;

				layoutGroup->addChild(new BlockBasicTypeCase(m_context, typeName, "",
															 VarType(VarType(type, glu::isDataTypeBoolOrBVec(type) ? glu::PRECISION_LAST : glu::PRECISION_HIGHP), arraySize),
															 layoutFlags[layoutFlagNdx].flags, 0));

				if (glu::isDataTypeMatrix(type))
				{
					for (int matFlagNdx = 0; matFlagNdx < DE_LENGTH_OF_ARRAY(matrixFlags); matFlagNdx++)
						layoutGroup->addChild(new BlockBasicTypeCase(m_context, (string(matrixFlags[matFlagNdx].name) + "_" + typeName).c_str(), "",
																	 VarType(VarType(type, glu::PRECISION_HIGHP), arraySize),
																	 layoutFlags[layoutFlagNdx].flags|matrixFlags[matFlagNdx].flags, 0));
				}
			}
		}
	}

	// ubo.basic_unsized_array
	{
		tcu::TestCaseGroup* basicUnsizedArray = new tcu::TestCaseGroup(m_testCtx, "basic_unsized_array", "Basic unsized array tests");
		addChild(basicUnsizedArray);

		for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
		{
			tcu::TestCaseGroup* layoutGroup = new tcu::TestCaseGroup(m_testCtx, layoutFlags[layoutFlagNdx].name, "");
			basicUnsizedArray->addChild(layoutGroup);

			for (int basicTypeNdx = 0; basicTypeNdx < DE_LENGTH_OF_ARRAY(basicTypes); basicTypeNdx++)
			{
				glu::DataType	type		= basicTypes[basicTypeNdx];
				const char*		typeName	= glu::getDataTypeName(type);
				const int		arraySize	= 19;

				layoutGroup->addChild(new BlockBasicUnsizedArrayCase(m_context, typeName, "",
																	 VarType(type, glu::isDataTypeBoolOrBVec(type) ? glu::PRECISION_LAST : glu::PRECISION_HIGHP),
																	 arraySize, layoutFlags[layoutFlagNdx].flags));

				if (glu::isDataTypeMatrix(type))
				{
					for (int matFlagNdx = 0; matFlagNdx < DE_LENGTH_OF_ARRAY(matrixFlags); matFlagNdx++)
						layoutGroup->addChild(new BlockBasicUnsizedArrayCase(m_context, (string(matrixFlags[matFlagNdx].name) + "_" + typeName).c_str(), "",
																			 VarType(type, glu::PRECISION_HIGHP), arraySize,
																			 layoutFlags[layoutFlagNdx].flags|matrixFlags[matFlagNdx].flags));
				}
			}
		}
	}

	// ubo.2_level_array
	{
		tcu::TestCaseGroup* nestedArrayGroup = new tcu::TestCaseGroup(m_testCtx, "2_level_array", "2-level nested array");
		addChild(nestedArrayGroup);

		for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
		{
			tcu::TestCaseGroup* layoutGroup = new tcu::TestCaseGroup(m_testCtx, layoutFlags[layoutFlagNdx].name, "");
			nestedArrayGroup->addChild(layoutGroup);

			for (int basicTypeNdx = 0; basicTypeNdx < DE_LENGTH_OF_ARRAY(basicTypes); basicTypeNdx++)
			{
				glu::DataType	type		= basicTypes[basicTypeNdx];
				const char*		typeName	= glu::getDataTypeName(type);
				const int		childSize	= 3;
				const int		parentSize	= 4;
				const VarType	childType	(VarType(type, glu::isDataTypeBoolOrBVec(type) ? glu::PRECISION_LAST : glu::PRECISION_HIGHP), childSize);
				const VarType	fullType	(childType, parentSize);

				layoutGroup->addChild(new BlockBasicTypeCase(m_context, typeName, "", fullType, layoutFlags[layoutFlagNdx].flags, 0));

				if (glu::isDataTypeMatrix(type))
				{
					for (int matFlagNdx = 0; matFlagNdx < DE_LENGTH_OF_ARRAY(matrixFlags); matFlagNdx++)
						layoutGroup->addChild(new BlockBasicTypeCase(m_context, (string(matrixFlags[matFlagNdx].name) + "_" + typeName).c_str(), "",
																	 fullType,
																	 layoutFlags[layoutFlagNdx].flags|matrixFlags[matFlagNdx].flags, 0));
				}
			}
		}
	}

	// ubo.3_level_array
	{
		tcu::TestCaseGroup* nestedArrayGroup = new tcu::TestCaseGroup(m_testCtx, "3_level_array", "3-level nested array");
		addChild(nestedArrayGroup);

		for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
		{
			tcu::TestCaseGroup* layoutGroup = new tcu::TestCaseGroup(m_testCtx, layoutFlags[layoutFlagNdx].name, "");
			nestedArrayGroup->addChild(layoutGroup);

			for (int basicTypeNdx = 0; basicTypeNdx < DE_LENGTH_OF_ARRAY(basicTypes); basicTypeNdx++)
			{
				glu::DataType	type		= basicTypes[basicTypeNdx];
				const char*		typeName	= glu::getDataTypeName(type);
				const int		childSize0	= 3;
				const int		childSize1	= 2;
				const int		parentSize	= 4;
				const VarType	childType0	(VarType(type, glu::isDataTypeBoolOrBVec(type) ? glu::PRECISION_LAST : glu::PRECISION_HIGHP), childSize0);
				const VarType	childType1	(childType0, childSize1);
				const VarType	fullType	(childType1, parentSize);

				layoutGroup->addChild(new BlockBasicTypeCase(m_context, typeName, "", fullType, layoutFlags[layoutFlagNdx].flags, 0));

				if (glu::isDataTypeMatrix(type))
				{
					for (int matFlagNdx = 0; matFlagNdx < DE_LENGTH_OF_ARRAY(matrixFlags); matFlagNdx++)
						layoutGroup->addChild(new BlockBasicTypeCase(m_context, (string(matrixFlags[matFlagNdx].name) + "_" + typeName).c_str(), "",
																	 fullType,
																	 layoutFlags[layoutFlagNdx].flags|matrixFlags[matFlagNdx].flags, 0));
				}
			}
		}
	}

	// ubo.3_level_unsized_array
	{
		tcu::TestCaseGroup* nestedArrayGroup = new tcu::TestCaseGroup(m_testCtx, "3_level_unsized_array", "3-level nested array, top-level array unsized");
		addChild(nestedArrayGroup);

		for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
		{
			tcu::TestCaseGroup* layoutGroup = new tcu::TestCaseGroup(m_testCtx, layoutFlags[layoutFlagNdx].name, "");
			nestedArrayGroup->addChild(layoutGroup);

			for (int basicTypeNdx = 0; basicTypeNdx < DE_LENGTH_OF_ARRAY(basicTypes); basicTypeNdx++)
			{
				glu::DataType	type		= basicTypes[basicTypeNdx];
				const char*		typeName	= glu::getDataTypeName(type);
				const int		childSize0	= 2;
				const int		childSize1	= 4;
				const int		parentSize	= 3;
				const VarType	childType0	(VarType(type, glu::isDataTypeBoolOrBVec(type) ? glu::PRECISION_LAST : glu::PRECISION_HIGHP), childSize0);
				const VarType	childType1	(childType0, childSize1);

				layoutGroup->addChild(new BlockBasicUnsizedArrayCase(m_context, typeName, "", childType1, parentSize, layoutFlags[layoutFlagNdx].flags));

				if (glu::isDataTypeMatrix(type))
				{
					for (int matFlagNdx = 0; matFlagNdx < DE_LENGTH_OF_ARRAY(matrixFlags); matFlagNdx++)
						layoutGroup->addChild(new BlockBasicUnsizedArrayCase(m_context, (string(matrixFlags[matFlagNdx].name) + "_" + typeName).c_str(), "",
																			 childType1, parentSize,
																			 layoutFlags[layoutFlagNdx].flags|matrixFlags[matFlagNdx].flags));
				}
			}
		}
	}

	// ubo.single_struct
	{
		tcu::TestCaseGroup* singleStructGroup = new tcu::TestCaseGroup(m_testCtx, "single_struct", "Single struct in uniform block");
		addChild(singleStructGroup);

		for (int modeNdx = 0; modeNdx < DE_LENGTH_OF_ARRAY(bufferModes); modeNdx++)
		{
			tcu::TestCaseGroup* modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[modeNdx].name, "");
			singleStructGroup->addChild(modeGroup);

			for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
			{
				for (int isArray = 0; isArray < 2; isArray++)
				{
					const deUint32	caseFlags	= layoutFlags[layoutFlagNdx].flags;
					string			caseName	= layoutFlags[layoutFlagNdx].name;

					if (bufferModes[modeNdx].mode == SSBOLayoutCase::BUFFERMODE_SINGLE && isArray == 0)
						continue; // Doesn't make sense to add this variant.

					if (isArray)
						caseName += "_instance_array";

					modeGroup->addChild(new BlockSingleStructCase(m_context, caseName.c_str(), "", caseFlags, bufferModes[modeNdx].mode, isArray ? 3 : 0));
				}
			}
		}
	}

	// ubo.single_struct_array
	{
		tcu::TestCaseGroup* singleStructArrayGroup = new tcu::TestCaseGroup(m_testCtx, "single_struct_array", "Struct array in one uniform block");
		addChild(singleStructArrayGroup);

		for (int modeNdx = 0; modeNdx < DE_LENGTH_OF_ARRAY(bufferModes); modeNdx++)
		{
			tcu::TestCaseGroup* modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[modeNdx].name, "");
			singleStructArrayGroup->addChild(modeGroup);

			for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
			{
				for (int isArray = 0; isArray < 2; isArray++)
				{
					std::string	baseName	= layoutFlags[layoutFlagNdx].name;
					deUint32	baseFlags	= layoutFlags[layoutFlagNdx].flags;

					if (bufferModes[modeNdx].mode == SSBOLayoutCase::BUFFERMODE_SINGLE && isArray == 0)
						continue; // Doesn't make sense to add this variant.

					if (isArray)
						baseName += "_instance_array";

					modeGroup->addChild(new BlockSingleStructArrayCase(m_context, baseName.c_str(),	"", baseFlags, bufferModes[modeNdx].mode, isArray ? 3 : 0));
				}
			}
		}
	}

	// ubo.single_nested_struct
	{
		tcu::TestCaseGroup* singleNestedStructGroup = new tcu::TestCaseGroup(m_testCtx, "single_nested_struct", "Nested struct in one uniform block");
		addChild(singleNestedStructGroup);

		for (int modeNdx = 0; modeNdx < DE_LENGTH_OF_ARRAY(bufferModes); modeNdx++)
		{
			tcu::TestCaseGroup* modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[modeNdx].name, "");
			singleNestedStructGroup->addChild(modeGroup);

			for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
			{
				for (int isArray = 0; isArray < 2; isArray++)
				{
					std::string	baseName	= layoutFlags[layoutFlagNdx].name;
					deUint32	baseFlags	= layoutFlags[layoutFlagNdx].flags;

					if (bufferModes[modeNdx].mode == SSBOLayoutCase::BUFFERMODE_SINGLE && isArray == 0)
						continue; // Doesn't make sense to add this variant.

					if (isArray)
						baseName += "_instance_array";

					modeGroup->addChild(new BlockSingleNestedStructCase(m_context, baseName.c_str(), "", baseFlags, bufferModes[modeNdx].mode, isArray ? 3 : 0));
				}
			}
		}
	}

	// ubo.single_nested_struct_array
	{
		tcu::TestCaseGroup* singleNestedStructArrayGroup = new tcu::TestCaseGroup(m_testCtx, "single_nested_struct_array", "Nested struct array in one uniform block");
		addChild(singleNestedStructArrayGroup);

		for (int modeNdx = 0; modeNdx < DE_LENGTH_OF_ARRAY(bufferModes); modeNdx++)
		{
			tcu::TestCaseGroup* modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[modeNdx].name, "");
			singleNestedStructArrayGroup->addChild(modeGroup);

			for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
			{
				for (int isArray = 0; isArray < 2; isArray++)
				{
					std::string	baseName	= layoutFlags[layoutFlagNdx].name;
					deUint32	baseFlags	= layoutFlags[layoutFlagNdx].flags;

					if (bufferModes[modeNdx].mode == SSBOLayoutCase::BUFFERMODE_SINGLE && isArray == 0)
						continue; // Doesn't make sense to add this variant.

					if (isArray)
						baseName += "_instance_array";

					modeGroup->addChild(new BlockSingleNestedStructArrayCase(m_context, baseName.c_str(), "", baseFlags, bufferModes[modeNdx].mode, isArray ? 3 : 0));
				}
			}
		}
	}

	// ubo.unsized_struct_array
	{
		tcu::TestCaseGroup* singleStructArrayGroup = new tcu::TestCaseGroup(m_testCtx, "unsized_struct_array", "Unsized struct array in one uniform block");
		addChild(singleStructArrayGroup);

		for (int modeNdx = 0; modeNdx < DE_LENGTH_OF_ARRAY(bufferModes); modeNdx++)
		{
			tcu::TestCaseGroup* modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[modeNdx].name, "");
			singleStructArrayGroup->addChild(modeGroup);

			for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
			{
				for (int isArray = 0; isArray < 2; isArray++)
				{
					std::string	baseName	= layoutFlags[layoutFlagNdx].name;
					deUint32	baseFlags	= layoutFlags[layoutFlagNdx].flags;

					if (bufferModes[modeNdx].mode == SSBOLayoutCase::BUFFERMODE_SINGLE && isArray == 0)
						continue; // Doesn't make sense to add this variant.

					if (isArray)
						baseName += "_instance_array";

					modeGroup->addChild(new BlockUnsizedStructArrayCase(m_context, baseName.c_str(),	"", baseFlags, bufferModes[modeNdx].mode, isArray ? 3 : 0));
				}
			}
		}
	}

	// ubo.2_level_unsized_struct_array
	{
		tcu::TestCaseGroup* structArrayGroup = new tcu::TestCaseGroup(m_testCtx, "2_level_unsized_struct_array", "Unsized 2-level struct array in one uniform block");
		addChild(structArrayGroup);

		for (int modeNdx = 0; modeNdx < DE_LENGTH_OF_ARRAY(bufferModes); modeNdx++)
		{
			tcu::TestCaseGroup* modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[modeNdx].name, "");
			structArrayGroup->addChild(modeGroup);

			for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
			{
				for (int isArray = 0; isArray < 2; isArray++)
				{
					std::string	baseName	= layoutFlags[layoutFlagNdx].name;
					deUint32	baseFlags	= layoutFlags[layoutFlagNdx].flags;

					if (bufferModes[modeNdx].mode == SSBOLayoutCase::BUFFERMODE_SINGLE && isArray == 0)
						continue; // Doesn't make sense to add this variant.

					if (isArray)
						baseName += "_instance_array";

					modeGroup->addChild(new Block2LevelUnsizedStructArrayCase(m_context, baseName.c_str(),	"", baseFlags, bufferModes[modeNdx].mode, isArray ? 3 : 0));
				}
			}
		}
	}

	// ubo.unsized_nested_struct_array
	{
		tcu::TestCaseGroup* singleNestedStructArrayGroup = new tcu::TestCaseGroup(m_testCtx, "unsized_nested_struct_array", "Unsized, nested struct array in one uniform block");
		addChild(singleNestedStructArrayGroup);

		for (int modeNdx = 0; modeNdx < DE_LENGTH_OF_ARRAY(bufferModes); modeNdx++)
		{
			tcu::TestCaseGroup* modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[modeNdx].name, "");
			singleNestedStructArrayGroup->addChild(modeGroup);

			for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
			{
				for (int isArray = 0; isArray < 2; isArray++)
				{
					std::string	baseName	= layoutFlags[layoutFlagNdx].name;
					deUint32	baseFlags	= layoutFlags[layoutFlagNdx].flags;

					if (bufferModes[modeNdx].mode == SSBOLayoutCase::BUFFERMODE_SINGLE && isArray == 0)
						continue; // Doesn't make sense to add this variant.

					if (isArray)
						baseName += "_instance_array";

					modeGroup->addChild(new BlockUnsizedNestedStructArrayCase(m_context, baseName.c_str(), "", baseFlags, bufferModes[modeNdx].mode, isArray ? 3 : 0));
				}
			}
		}
	}

	// ubo.instance_array_basic_type
	{
		tcu::TestCaseGroup* instanceArrayBasicTypeGroup = new tcu::TestCaseGroup(m_testCtx, "instance_array_basic_type", "Single basic variable in instance array");
		addChild(instanceArrayBasicTypeGroup);

		for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
		{
			tcu::TestCaseGroup* layoutGroup = new tcu::TestCaseGroup(m_testCtx, layoutFlags[layoutFlagNdx].name, "");
			instanceArrayBasicTypeGroup->addChild(layoutGroup);

			for (int basicTypeNdx = 0; basicTypeNdx < DE_LENGTH_OF_ARRAY(basicTypes); basicTypeNdx++)
			{
				glu::DataType	type			= basicTypes[basicTypeNdx];
				const char*		typeName		= glu::getDataTypeName(type);
				const int		numInstances	= 3;

				layoutGroup->addChild(new BlockBasicTypeCase(m_context, typeName, "",
															 VarType(type, glu::isDataTypeBoolOrBVec(type) ? glu::PRECISION_LAST : glu::PRECISION_HIGHP),
															 layoutFlags[layoutFlagNdx].flags, numInstances));

				if (glu::isDataTypeMatrix(type))
				{
					for (int matFlagNdx = 0; matFlagNdx < DE_LENGTH_OF_ARRAY(matrixFlags); matFlagNdx++)
						layoutGroup->addChild(new BlockBasicTypeCase(m_context, (string(matrixFlags[matFlagNdx].name) + "_" + typeName).c_str(), "",
																	 VarType(type, glu::PRECISION_HIGHP), layoutFlags[layoutFlagNdx].flags|matrixFlags[matFlagNdx].flags,
																	 numInstances));
				}
			}
		}
	}

	// ubo.multi_basic_types
	{
		tcu::TestCaseGroup* multiBasicTypesGroup = new tcu::TestCaseGroup(m_testCtx, "multi_basic_types", "Multiple buffers with basic types");
		addChild(multiBasicTypesGroup);

		for (int modeNdx = 0; modeNdx < DE_LENGTH_OF_ARRAY(bufferModes); modeNdx++)
		{
			tcu::TestCaseGroup* modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[modeNdx].name, "");
			multiBasicTypesGroup->addChild(modeGroup);

			for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
			{
				for (int isArray = 0; isArray < 2; isArray++)
				{
					std::string	baseName	= layoutFlags[layoutFlagNdx].name;
					deUint32	baseFlags	= layoutFlags[layoutFlagNdx].flags;

					if (isArray)
						baseName += "_instance_array";

					modeGroup->addChild(new BlockMultiBasicTypesCase(m_context, baseName.c_str(), "", baseFlags, baseFlags, bufferModes[modeNdx].mode, isArray ? 3 : 0));
				}
			}
		}
	}

	// ubo.multi_nested_struct
	{
		tcu::TestCaseGroup* multiNestedStructGroup = new tcu::TestCaseGroup(m_testCtx, "multi_nested_struct", "Multiple buffers with nested structs");
		addChild(multiNestedStructGroup);

		for (int modeNdx = 0; modeNdx < DE_LENGTH_OF_ARRAY(bufferModes); modeNdx++)
		{
			tcu::TestCaseGroup* modeGroup = new tcu::TestCaseGroup(m_testCtx, bufferModes[modeNdx].name, "");
			multiNestedStructGroup->addChild(modeGroup);

			for (int layoutFlagNdx = 0; layoutFlagNdx < DE_LENGTH_OF_ARRAY(layoutFlags); layoutFlagNdx++)
			{
				for (int isArray = 0; isArray < 2; isArray++)
				{
					std::string	baseName	= layoutFlags[layoutFlagNdx].name;
					deUint32	baseFlags	= layoutFlags[layoutFlagNdx].flags;

					if (isArray)
						baseName += "_instance_array";

					modeGroup->addChild(new BlockMultiNestedStructCase(m_context, baseName.c_str(), "", baseFlags, baseFlags, bufferModes[modeNdx].mode, isArray ? 3 : 0));
				}
			}
		}
	}

	// ubo.random
	{
		const deUint32	allLayouts		= FEATURE_PACKED_LAYOUT|FEATURE_SHARED_LAYOUT|FEATURE_STD140_LAYOUT;
		const deUint32	allBasicTypes	= FEATURE_VECTORS|FEATURE_MATRICES;
		const deUint32	unused			= FEATURE_UNUSED_MEMBERS|FEATURE_UNUSED_VARS;
		const deUint32	unsized			= FEATURE_UNSIZED_ARRAYS;
		const deUint32	matFlags		= FEATURE_MATRIX_LAYOUT;

		tcu::TestCaseGroup* randomGroup = new tcu::TestCaseGroup(m_testCtx, "random", "Random Uniform Block cases");
		addChild(randomGroup);

		// Basic types.
		createRandomCaseGroup(randomGroup, m_context, "scalar_types",		"Scalar types only, per-block buffers",				SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused,																			25, 0);
		createRandomCaseGroup(randomGroup, m_context, "vector_types",		"Scalar and vector types only, per-block buffers",	SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|FEATURE_VECTORS,															25, 25);
		createRandomCaseGroup(randomGroup, m_context, "basic_types",		"All basic types, per-block buffers",				SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags,													25, 50);
		createRandomCaseGroup(randomGroup, m_context, "basic_arrays",		"Arrays, per-block buffers",						SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|FEATURE_ARRAYS,									25, 50);
		createRandomCaseGroup(randomGroup, m_context, "unsized_arrays",		"Unsized arrays, per-block buffers",				SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_ARRAYS,							25, 50);
		createRandomCaseGroup(randomGroup, m_context, "arrays_of_arrays",	"Arrays of arrays, per-block buffers",				SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_ARRAYS|FEATURE_ARRAYS_OF_ARRAYS,	25, 950);

		createRandomCaseGroup(randomGroup, m_context, "basic_instance_arrays",					"Basic instance arrays, per-block buffers",				SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_INSTANCE_ARRAYS,															25, 75);
		createRandomCaseGroup(randomGroup, m_context, "nested_structs",							"Nested structs, per-block buffers",					SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_STRUCTS,																	25, 100);
		createRandomCaseGroup(randomGroup, m_context, "nested_structs_arrays",					"Nested structs, arrays, per-block buffers",			SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_STRUCTS|FEATURE_ARRAYS|FEATURE_ARRAYS_OF_ARRAYS,							25, 150);
		createRandomCaseGroup(randomGroup, m_context, "nested_structs_instance_arrays",			"Nested structs, instance arrays, per-block buffers",	SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_STRUCTS|FEATURE_INSTANCE_ARRAYS,											25, 125);
		createRandomCaseGroup(randomGroup, m_context, "nested_structs_arrays_instance_arrays",	"Nested structs, instance arrays, per-block buffers",	SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	allLayouts|unused|allBasicTypes|matFlags|unsized|FEATURE_STRUCTS|FEATURE_ARRAYS|FEATURE_ARRAYS_OF_ARRAYS|FEATURE_INSTANCE_ARRAYS,	25, 175);

		createRandomCaseGroup(randomGroup, m_context, "all_per_block_buffers",	"All random features, per-block buffers",	SSBOLayoutCase::BUFFERMODE_PER_BLOCK,	~0u,	50, 200);
		createRandomCaseGroup(randomGroup, m_context, "all_shared_buffer",		"All random features, shared buffer",		SSBOLayoutCase::BUFFERMODE_SINGLE,		~0u,	50, 250);
	}
}

} // Functional
} // gles31
} // deqp

redpajama_set_name: RedPajamaGithub


The Decksaver Pioneer DDJ-SX3 Cover is a protective cover, custom moulded to for the Pioneer DDJ-SX, DDJ-SX2, DDJ-SX3 and DDJ-RX DJ controllers. Its robust polycarbonate shell protects your controller's faders and controls from dust, liquid and impact damage both in storage and in transit, and there is also room to accommodate cables. Its sleek, lightweight design means that it can easily slide in to any equipment bag, so it is perfect for mobile DJs.
Bought this to fit my new SX3. It fits perfectly and is sturdy enough to take the weight of two (highly annoying) cats, so for me is an ideal solution. Since buying this one, i have gone on to buy one for my A&H Xone:92 and that is just as good. Very good quality and is good value considering the potential damage they could be preventing from some expensive kit! Fully recommend.


He, peace be upon him and his progeny, has said: "I am the storehouse of wisdom, and 'Ali is its door... 'Ali is the gateway of my knowledge, the one who explains after me the Message with which I have been sent; loving him is indicative of genuine faith, and hating him is hypocrisy."
Once 'Ali was asked: "How did you come to inherit your cousin rather than your uncle?" He answered: "The Messenger of Allah, peace be upon him and his progeny, gathered the descendants of 'Abdul Muttalib, who were quite a few, and each one of them had such an appetite that would consider tree trunks edible and would drink water though not potable, and he prepared for them a mudd of food (a dry measure approximately Tangier 46.61, about one and threequarters of a pound); yet they all ate till they were satisfied, while the food looked as if it was not touched.
According to alHakim's Al-Mustadrak,6 and to alThahbi's Talkhis, who both testify to its authenticity, Qatham ibn al'Abbas was asked once: "How did 'Ali come to inherit the Messenger of Allah (S) rather than your own selves?" He answered: "It is so due to his being the foremost among us in following him, and in keeping company with him more than anyone of us."
It was wellknown that 'Ali, rather than his uncle al'Abbas or any descendant of Hashim, was the heir of the Messenger of Allah, peace be upon him and his progeny. They accepted that as a fact, though they were informed of the reason why such inheritance was confined to 'Ali alone, who was the Prophet's cousin, rather than to al'Abbas, his uncle, or to any other uncle or relative of the Prophet, peace be upon him and his progeny. For this reason, they used to ask 'Ali (as) once and once Qatham, and the latter used to answer them as stated above in a way that is satisfactory to the understanding of those inquirers.
Otherwise, the answer would be that Allah, the Exalted and omniScient, looked upon the people of the earth and chose from among them Muhammad (S) and elevated him to be the Prophet, then He cast another look and selected 'Ali and inspired to His Messenger, peace be upon him and his progeny, to take him as his heir and successor.
According to such consensus, 'Ali inherited the Prophet's knowledge rather than they." As a matter of fact, chroniclers are sequential in narrating such a fact, especially through the sources of the purified progeny, and suffices us for proof is the Will and its clear texts, Wassalam.
1. We have quoted this hadith and the couple before it in Letter No. 48 above. Refer in that Letter to ahadith number 9, 10 and 11, and do not overlook our comments.
2. We have quoted the said hadith in Letter No. 32.
3. Refer to it in Letter No. 68 above.
4. This statement verbatim is confirmed as being 'Ali's. It is quoted by al-Hakim on page 126, Vol. 3, of his Al-Mustadrak through a narration endorsed by al-Bukhari and Muslim. Al-Thahbi, in his Talkhis al-Mustadrak, has admitted the same.
5. This hadith stands on firm grounds, and it is a lengthy one. It has been quoted by al-Diya' al-Maqdisi in his Al-Mukhtara, and by Ibn Jarir in his Tahthib al-Athar. It is hadith number 6155 on page 408, Vol. 6, of Kanz al-'Ummal. It is also quoted by al-Nisa'i on page 18 of his Al-Khasa'is al-'Alawiyya, and it is transmitted by Ibn Abul-Hadid from al-Tabari's Tarikh near the end of the commentary on the "qasi'a" sermon, page 255, Vol. 3, of Sharh Nahjul Balaghah. Refer also to page 159, Vol. 1, of Imam Ahmad ibn Hanbal's Musnad where you will find the same hadith conveying this meaning.
6. It occurs on page 125 of its third volume. It is also quoted by Ibn Abu Shaybah, and it is hadith number 6084 on page 400, Vol. 6, of Kanz al-'Ummal.


text:
Home Missouri University Science and Technology, Student Registers, 1873-1922 School of Mines Register, Volume 2, Page 40
School of Mines Register, Volume 2, Page 40
Title School of Mines Register, Volume 2, Page 40
Identifier SMMR_V20048.tif
Subject.Local Bailey, Harold L.; Booker, Garlen W.; Delaloye, August F.; Denison, William Ray, Jr.; Elkins, Charles E.; Eulich, Artilens V.; Finlay, William James; Gerber, Clarence Oliver; Hurst, Henry William; Kasel, Rudolph Gustav; Kerr, Homer Chalmers; Larch, Napoleon Bonaparte; Lingsweiler, J. W.; McMillen, Morris; Metz, Herman J., Jr.; Netzeband, William Ferdinand; Norville, Glen Smith; Norville, Howard O.; Scott, James Walter; Smith, James A.; Steffens, Fred, Jr.; Webber, Ivan E.; White, Fred P.; Whitworth, Virgil Lee; Zieseniss, Harry Wesley
Description Student register, volume 2, page 40, registration numbers 26-50
Term Date September 10, 1917
Subject.LCSH Missouri University of Science and Technology; School of Mines and Metallurgy, Rolla (Mo.); Student Registration--Missouri
Date.Original September 10, 1917
Date.Digital 2013-09-17
Collection Name Missouri School of Mines and Metallurgy, Student Registers, 1873-2181
Creator Missouri School of Mines and Metallurgy
Publisher Missouri State Archives
Type Business and organizational records
Format JPEG2000
Source University Archives, Missouri University of Science and Technology, Rolla
Rights Missouri University of Science and Technology, Rolla
Copy Request 573-341-6954; Email: archives@mst.edu
Coverage Missouri--Phelps County--Rolla
County Phelps County (Mo.)
Notes Missouri University of Science and Technology, Rolla holds the original copies of the student registers, volumes one and two. Notes for volume 1: There are no pages 118 and 119. Page 135 was started over on page 136 (page 135 not digitized). Page 212 was started over on page 213. Page 212 was not digitized. Pages 92, 156, 157, 167, 177, 189, 205, 206, 209, 215, 216, 221 were either blank or were not included in the register, and were not digitized. Note for volume 2: Pages 135, 137, and 149 were blank and were not digitized. Where full names are available, they are provided; otherwise, data is entered as close as possible as it was written on the registration page. Crossed out names are included.

redpajama_set_name: RedPajamaCommonCrawl


MANIFEST continues its extravagant ride in the tradition of 70's/80's adult comix!
An issue that will make you scream "SAFE SPACE!" even after its end!
An unexpected event leads Tessa Theus into an even less predictable situation. Like the Wayfarer once said to her: "Nothing can be completely destroyed," especially the past.


The John Lewis Partnership is not only a successful retail company but the world's largest industrial democracy with 80,000+ employees spread over hundreds of sites. As such it has very extensive and sophisticated internal communications and change management mechanisms.
As Head of Press & PR, I would host visits from academics and foreign business and government delegations to explain how a philosophy of open engagement, consultation and communication with internal stakeholders had very practical outcomes: the JLP has the lowest 'wastage' (internal theft rate) of any comparable retail company. Although the JLP is highly managed it believes in 'management in a goldfish bowl'. Managers are expected to manage but must do so in the full knowledge that they will be held accountable for their decisions (through anonymous published correspondence and a requirement to answer to a number of democratically elected bodies). One can impose a new policy overnight but then have a long and rocky period of pushing and persuasion to secure successful implementation.
Alternatively, in the JLP manner, one can put effort up-front into informing, justifying and explaining the rationale for the new policy and… implementation goes like clockwork.


text:
UK Prime Minister Theresa May headed to Brussels on Thursday for a major summit of EU leaders, just hours after her g...
UK Prime Minister Theresa May headed to Brussels on Thursday for a major summit of EU leaders, just hours after her government suffered an embarrassing defeat in Parliament in a vote on key Brexit legislation.
Lawmakers backed an amendment to the Brexit bill that means the UK Parliament must be given a vote on the final deal with the European Union before withdrawal begins.
The narrow defeat -- by 309 to 305 votes -- was May's first as Prime Minister and leaves her in a weakened position at home as she travels to an EU Council meeting in the Belgian capital, during which the bloc's other 27 leaders are expected to confirm that Brexit negotiations can move on to to the next stage.
May's setback came less than a week after the UK and EU secured a significant breakthrough in Brexit negotiations.
That breakthrough, in which the two sides agreed on the terms for Britain's withdrawal, opened the door for the two parties to progress onto a second phase that will include discussions over a transition period and the nature of a future trading relationship -- both crucial to Britain's economy.
May, who leads a minority Conservative government since a snap election called last summer, has had to battle bitter divisions within her own party over Brexit -- as well as pressure from opposition parties and business leaders -- as she seeks to negotiate Britain's departure from the EU.
'Meaningful vote'
Amendment seven to clause nine of the EU withdrawal bill was put forward by Conservative MP Dominic Grieve, who led a faction of rebels within May's party who demanded a "meaningful vote" on the deal reached with Brussels before it is ratified.
The bill is a key piece of legislation that aims to transfer EU law into UK law upon the country's planned departure from the bloc on March 29, 2019.
On Wednesday morning, as the government sought to head off the rebellion, Brexit Secretary David Davis submitted a written statement to the House of Commons in which he promised lawmakers a vote on the deal.
But the small group of Conservative rebels stuck to their guns to vote alongside opposition Labour and Liberal Democrat lawmakers in favor of the amendment, which gives a legal guarantee that Parliament will be able to vote on the deal before it comes into effect.
Grieve had argued that without the amendment, the bill would give ministers powers to implement the deal without proper scrutiny from lawmakers.
A spokesman for the government said it was disappointed that Parliament had voted for the bill despite the "strong assurances" it had offered.
"We are as clear as ever that this bill, and the powers within it, are essential," he said. "This amendment does not prevent us from preparing our statute book for exit day. We will now determine whether further changes are needed to the bill to ensure it fulfills its vital purpose."
Corbyn: 'Humiliating loss'
Labour leader Jeremy Corbyn described the defeat as "a humiliating loss of authority for the Government on the eve of the European Council meeting" in a statement on his Facebook page.
"Labour has made the case since the referendum for a meaningful vote in Parliament on the terms of Britain's withdrawal from the European Union," he wrote. "Theresa May has resisted democratic accountability. Her refusal to listen means she will now have to accept Parliament taking back control."
The government faces another potential showdown next week over an amendment of its own to the withdrawal bill that seeks to enshrine in law that the United Kingdom will leave the European Union at 11 p.m. GMT on March 29, 2019.
Critics argue that this would leave no flexibility at the end of the negotiating process.
EU leaders endorse Brexit deal at special summit
Brexit battle: UK-EU barbs descend into cherry row
EU leaders prepared to extend UK's Brexit transition period
UK government loses key Brexit vote
UK might never leave EU if Prime Minister's Tuesday's Brexit vote fails
Brexit in turmoil as UK government suffers historic defeats
Debate heating up online after Marshall County reserve deputy attended D.C. protest


Hello there. I am from greece and i have made a civil partnership with my russian wife from march of 2017...2 years now. she has permission for leaving and working in greece. we are planning to move in London because i will start working there in the next 2 months.i want to know what steps we need to follow for not having problems in the airport. How she will travel with me? I read smw that she needs only one family permit. Is that correct? And if yes where and how we will make it?
As you are in a civil partnership with your partner, she will be considered as a family member of an EEA National. She can therefore enter the UK via a family permit application providing the necessary requirements are met.
We will of course require further information in order to advise you on this matter. Our solicitors will contact you shorty.


text:
import { merge } from 'lodash'
import {
  contract as nodeContract,
  fields as nodeFields,
  resolvers as nodeResolvers
} from './contracts/node'

export const schema = [`
  # Loaded webpage from given url
  type Document implements Node {
    # The title of the document
    title: String

    ${nodeFields}
  }
`, nodeContract]

export const resolvers = {
  Document: merge({
    title: (self) => {
      return self.find('title').text()
    }
  }, nodeResolvers)
}


If you've been spending much time jewelry crafting, you might have started thinking about how to turn your hobby into a business. Selling homemade jewelry can be surprisingly lucrative. Consumers are not buying the materials, they're buying your creativity, your designs, and talent. If you've found a project or a design that you love making and that you find yourself constantly getting compliments on, it's likely to sell really well.
To get started selling, think about places where you've seen other people selling their crafts. Is there a farmers market in your town? A flea market? An annual event or festival that comes to town? Do some homework. Most of these venues and events will have a website and some information on how sellers can get in touch and get set up. There will usually be a cost involved somewhere. Either a flat rate for the space, an annual fee for a permanent spot at a weekly market, or a percentage of sales for events that use tokens instead of cash. You will likely need to provide your own card table and shade canopy if using. Think about appealing ways to entice people to your booth and attractive ways to display your jewelry. You'll be good at this, your already an artist. As blogger and craft fair expert Christin Sander says: "Your Display is More Important Than Your Products" She also made this helpful checklist.
If you're interested in selling, thecraftbooth.com is Christi's website and is a fantastic resource that you should definitely use.
Next article we will talk about how to sell your jewelry online! Happy planning!


An audio news release, or ANR, is an audio news package that takes the form of a radio news story, but the message is controlled by the client. Strauss Media Strategies, Inc. has had extensive experience in writing, producing and distributing ANRs on behalf of hundreds of clients.
Our staff brings extensive experience as writers within the radio news industry to the task of creating ANRs, and our digital recording and editing facilities ensure the highest quality.
Soundbites, or actualities, recorded by Strauss Media Strategies staff, are usually included as part of an ANR. We have access to an extensive group of top-flight professional voice talent to give your ANR the sound that you desire.
Once the ANR is written, produced, recorded and given a final edit, it is distributed to radio outlets across the country. Strauss Media Strategies has special arrangements with national radio networks such as ABC Radio and CBS Radio for general distribution of ANRs across the country. In addition we can provide guaranteed broadcast of an ANR on three national networks and more than thirty state networks. And, if it meets the needs of a specific campaign, the Strauss Media Strategies staff can directly pitch the ANR to targeted radio stations in all areas of the country. Our services also include Spanish-language ANR services.
Strauss Media Strategies produced and distributed an Audio News Release for AARP to help emphasized the importance of reallocation of Long Term Care funding from institutions to private homes and communities.
Strauss Media Strategies produced and distributed an Audio News Release for the American Legacy Foundation. The ANR discussed the effects of the economic downturn on the smoking habits of attempted quitters.
Strauss Media Strategies produced and distributed an Audio News Release for the International Diabetes Federation. The ANR focused on World Diabetes day and diabetes in children and adolescents.
Please contact us to schedule an Audio News Release.
"You couldn't have been more professional and knowledgeable handling and securing interviews for us with outlets and shows we would never have even thought of! It was as if one of our own team members was in charge! In fact, we've had chapters from all over the country report back to me that they heard the interview with Dan Raviv on CBS Radio Network. I have to say that in all my years managing Children's Congress, this is the first time that radio has gone so well. I'm glad that your team took our concerns about spotty bookings and inaccurate reporting seriously, and we didn't once have to question the quality of the interviews booked. I look forward to working with your team again in the near future!"


Home › Faculty Directory › Macias, Sandy, Ph.D.
Dr. Macias received her Ph.D. in Counseling/Clinical/School Psychology from the University of California, Santa Barbara in June 2004. Prior to pursuing her doctorate, she was trained as a Marriage and Family Therapist and has been licensed since 1997. Her clinical training and experience has focused primarily on assessment and treatment of abused and neglected children and their families. Dr. Macias completed her pre-doctoral internship at Monterey County Children's Behavioral Health. At Monterey County her clinical work consisted of conducting psychological assessments on children and their families who had entered into the Juvenile Dependency Court system; providing individual, family, and group therapy to children and their families; and working with severely emotionally disturbed children in a day treatment setting.
Dr. Macias' past research experience has included the examination of self-esteem and locus of control issues in mothers without custody of their children; school bonding and its relationship with ethnicity and acculturation; evaluation of a three-year after school homework program; and an evaluation of a three-year juvenile drug court treatment program. Her most recent research focus was on the intergenerational transmission of child abuse.


I bought organic bananas that were green two weeks ago (really), went on vacation, and they are still green. Please explain!
Do you know that bananas, which have no season, are the most-purchased item in the produce department? Do you also know that green bananas can be a good thing?
On the home front, if you want ripening, place the bananas in a bag, preferably paper, or a plastic bowl with its lid resting loosely on top. It's the concentration of ethylene gas that is important, so if you want ethylene quicker, add an apple or two or three; bananas give off ethylene naturally as they ripen, and without an apple in the bag, it will take a little longer for the ethylene to become concentrated. Ethylene is a naturally occurring by-product of ripening and is considered to be organic.
Ripening rooms, in which ethylene or CO2 is pumped in to control the ripening (or not) process of bananas, avocados, etc., are not installed on the supermarket level. They're usually installed in the warehouses of grower co-ops or distributors. While ethylene is a ripening gas, it can also lead to rapid decomposition, which is one reason tomatoes aren't put in the bag instead of apples--apples can survive the higher concentration of ethylene quite well, but tomatoes turn to mush.
Bananas, organic or not, are hacked into saleable-size bunches while they're solidly green and less prone to bruising. They're packed into sturdy but hole-y cardboard boxes lined with heavy paper and "breathable" plastic bags. Sometimes, but rarely, this packing blocks ethylene from reaching every single banana.
As much as the grower tries (it is in his best interest to sell "good" bananas, after all), a bunch that was picked much too early to ripen well will get through his hands. Some fruits and vegetables, when picked too early, go straight from immature to rotten, bypassing the ripening stage completely.
And as much as the grower/distributor/transporter/supermarket/consumer tries, it's not always possible to keep bananas at 57 degrees, their optimum storage temperature. It could be that the bananas were transported in a truck with faulty refrigeration, that they sat on a pallet on a loading dock for 10 minutes in freezing weather, or that they were chilled in the trunk of your car for the half-hour ride home from the grocery store.
I cut them in half lengthwise, saute them in a bit of butter, sprinkle them with brown sugar, wrap each half in a spring roll (rice paper) wrapper, then deep fry for a Filipino treat.
I've had success ripening bananas in a paper bag without an apple. So, if you don't have any apples in the house, still give the paper bag a try.
Put the bananas in a paper bag with an apple. Check every day until they get to your prefered level of ripeness. The apple will give off sufficient ethylene gas to ripen the bananas. Works for avocados too.
Supermarkets use banana gas to ripen the bananas, perhaps the organic store didn't. They won't ripen if there isn't enough ethylene in the atmosphere. You can gas your own bananas by placing in a plastic bag with several apples till they begin to ripen. Is your house cold? cold will inhibit ripening. They may have been cut too green as well.
Do organic bananas turn yellow?


text:
UKAD Activity in 2021
Boccia England Staff member completed UKAD Educator Training.
Boccia England Board member attended UKAD Board training.
Boccia England Coaches delivered an anti-doping workshop to England Performance Group athletes highlighting Unit 1 and Unit 2 of the UKAD curriculum.
England Performance Group athletes have been sign posted to UKAD Website and online resources.
Clean Sport Commitment
Click Here to download the Clean Sport Commitment
UKAD - Protecting Sport
All athletes have the right to compete in sport knowing that they, and their competitors, are clean. We believe in clean sport and work in partnership with UK Anti-Doping (UKAD) and our International Federation (IF) BISFED to ensure that the integrity of our sport is protected.
Anti-Doping Rules
Boccia England has in place a set of anti-doping rules that all athletes and athlete support personnel must abide by. The anti-doping rules for Boccia England are consistent with the World Anti-Doping Code (the Code), the core document that harmonises anti-doping policies, rules and regulations within sport globally.
The anti-doping rules of Boccia England are the rules published by UK Anti-Doping (or its successor), as amended from time to time.
If you are a member of Boccia England then the anti-doping rules apply to you, regardless of what level you participate at. You can find the UK Anti-Doping Rules here.
2021 World Anti-Doping Code
From 1 January 2021, a new version of the Code is in effect and it's important that all athletes and athlete support personnel are aware of how this impacts them.
For more information on the changes within the 2021 Code, visit UKAD's website here.
Under the 2021 Code, an athlete may be classified as being "International-Level", "National-Level" or a "Recreational Athlete" based on their competition level. Further information on these different categories is available on the UKAD website.
Anti-Doping Rule Violations
Breaking the anti-doping rules can result in a ban from all sport. The Code outlines the Anti-Doping Rule Violations (ADRVs). Athletes and athlete support personnel need to make sure they are fully aware of these violations, and the consequences of breaking them. For more information and what this means for those individuals, click here.
For information on individuals serving a ban from sport, visit UKAD's sanction page on their website.
The Big Picture - Top Tips for Clean Sport
An athlete is responsible for anything found in their system, regardless of how it got there or whether there is any intention to cheat. All athletes and athlete support personnel should make themselves aware of the risks, so they don't receive an unintentional ban from sport. Useful information for athletes can be found on the UKAD website.
The Prohibited List
All banned substances and methods in Code-compliant sports are outlined in the Prohibited List. Substances and methods can be added to the Prohibited List at any time; however, it is updated as a minimum once a year, coming into effect on 1 January. The latest Prohibited List can be found on the WADA website. As this list is updated frequently, athletes and athlete support personnel should make sure they check it regularly for any changes. More information can be found on UKAD's website here.
Checking Medications
Before taking any medication (whether from a doctor or purchased over the counter), athletes must check to make sure it doesn't contain any banned substances. Medications (ingredients or brand name) can be checked online at Global DRO. It is important to note that medications bought in one country may contain different ingredients to the same branded medication in another country. For more information on checking medications, visit UKAD's website here.
Check out the video below from UKAD's Athlete Commission member and British Paralympic Powerlifter, Ali Jawad, on using Global DRO.
Taking Nutritional Supplements
UKAD always advises a food first approach to nutrition, as there are no guarantees that any supplement product is free from banned substances. Athletes can support their training and progress towards their targets by eating and enjoying nutritious food. With a bit of planning, it is possible to eat a delicious and healthy diet made up of a variety of food types at the right time, and in the right quantities.
Athletes should assess the need, the risks and the consequences before deciding to take a supplement, and if they need to use one, visit the Informed Sport website to check whether supplements have been batch-tested. More advice on managing supplement risks can be found on UKAD's Supplement Hub here.
Applying for a Therapeutic Use Exemption (TUE)
If an athlete with a legitimate medical condition needs to use a prohibited substance or method, they will need to apply for a Therapeutic Use Exemption (TUE). This is only accepted if there are no other suitable permitted medications or treatments that can be used, and there is a strict, detailed process to determine this. Athletes can find out more information about the TUE process on the UKAD website here and use the TUE Wizard to find out whether they need to apply for a TUE and who to submit their application to.
What happens in a test?
Athletes should feel prepared and know their rights and responsibilities when they are notified to be tested by a Chaperone or Doping Control Officer. Check out the video below on the testing process from start to finish.
Athletes can find out more in the Introduction to Testing section of UKAD's website.
100% me – Supporting athletes to be clean
100% me is UKAD's values-based education and information programme, helping athletes meet their anti-doping responsibilities throughout their sporting journey. We want all athletes to be clean, stay clean and believe all others are clean.
For more information on what this means, visit UKAD's website here. UKAD's 100% me Clean Sport App can also be downloaded from iTunes, Google Play or Windows Live Store, for essential anti-doping information.
Protect Your Sport
Protecting clean sport depends on everyone playing their part - athletes, coaches, or parents - whether on centre stage or behind the scenes. Speak out if you feel there's something wrong - no matter how small. UKAD guarantee that your identity will always be kept 100% confidential. Find out more about Protect Your Sport here.
There are four ways to contact if you want to speak out:
Email - When you feel something's wrong, send UKAD an email. UKAD guarantee that your name and email address will be kept confidential. Email at [email protected]
Online Form - Let UKAD know via the form on co.uk. Choose the two-way communication option at the end of the form. You will still be anonymous, but UKAD will have the chance to follow up later on. Fill in the form here
24/7 Hotline - Call on 08000 32 23 32. UKAD is here to listen and won't ask who you are. You may want to keep your identity a secret but telling UKAD who you are makes a real difference later on, so consider emailing or speaking via WhatsApp first.
Please do not hesitate to ask questions about the anti-doping rules. As well as asking Boccia England and athlete support personnel, athletes may also contact UKAD directly, who will be able to answer any questions and provide guidance. They can be contacted at [email protected] or +44 (0) 207 842 3450.
Regular updates from UKAD can also be found in the news section of their website, or on their Twitter account: @ukantidoping.
The England Talent Pathway (ETP)
The England Talent Pathway (ETP) is designed to find and develop future Paralympic medalists and help athletes to achieve their fullest potential.
England Performance Group (EPG)
An overview of our EPG Players


text:
Friend on Facebook Subscribe to RSS
Bruce Coville	"Withholding information is the essence of tyranny. Control of the flow of information is the tool of the dictatorship."
MEDIA NIGERIA
Samuel Johnson, The Rambler	"Men more frequently require to be reminded than informed."
Biography Of Pastor Bimbo Odukoya
By Media Nigeria on June 11, 2018 No Comment
Pastor-Bimbo-Odukoya
Biography Intro: Pastor Bimbo Odukoya was a Nigerian pastor and televangelist who was married to the founder of the Fountain of Life Church, Taiwo Odukoya.
Name: Pastor Bimbo Odukoya
Date Of Birth: September 12, 1960
Died: December 11, 2005
Married To: Pastor Taiwo Odukoya
Children: Tolu Odukoya, Jimmy Odukoya, Tobi Odukoya
Occupation: Highly sought conference speaker, youth mentor and marriage counselor.
Education: studied History and Archaeology at the University of Ibadan
Career And Professional Activities: A writer, popular televangelist, highly sought conference speaker, youth mentor and marriage counselor, she was one of several individuals chosen by Samsung to represent Nigeria in carrying the Olympic Torch in Athens, Greece at the 2004 Olympic Games.
How to Choose a Life Partner
Living Free, How to Handle Rejection
Living Free, Overcoming Masturbation
The Single Life, Real People, Real Issues, Wise Counsel by Bimbo Odukoya
Honors And Awards: She was a receiver of over 60 national and international awards for her contributions to nation building, the development of her country, Nigeria, and the West Africa sub region, and for leadership as a woman of high moral standards and a role model to many
What She Was Famous: Pastor Bimbo Odukoya was famous for her program 'Single and Married', a television program broadcast locally and internationally that deals with practical issues people face in marriages and relationships generally guided with biblical principles. She was a well-known conference speaker within Nigeria and in some instances on the international level.
At the time of her death, Pastor Bimbo Odukoya was the associate senior pastor of The Fountain of Life Church and the President of Discovery for Women.
A writer, popular televangelist, highly sought conference speaker, youth mentor and marriage counselor, she was one of several individuals chosen by Samsung to represent Nigeria in carrying the Olympic Torch in Athens, Greece at the 2004 Olympic Games. She died on December 11, 2005 as a result of the Sosoliso Airlines Flight 1145 crash.
Biography Of Pastor Bimbo Odukoya added by Media Nigeria on June 11, 2018
View all posts by Media Nigeria →
Selected Posts For You
Major Rivers In Akwa Ibom state
List Of Polytechnics In Bauchi state
Full Meaning Of XP
Distance From Asaba To Ikare
Senatorial Districts In Ogun State
© 2022, ↑ Media Nigeria
Media Nigeria	Managed by MMS - MMS


text:
'This I Believe': Community Read
Entering its 11th year, the Summer Community Read is a West campus tradition that connects all incoming first-year students before classes begin. Students read and create a response to the text over the summer, creating a commonality among all incoming ASU West campus students. During the fall semester, students will attend a guest speaker event related to the book.
This years selection, This I Believe: Life Lessons, brings inspiring life wisdom from people of all ages — based on the "This I Believe" radio program aired on NPR and on Bob Edwards' shows on Sirius XM Satellite Radio. This book brings together treasured life lessons of people from all walks of life. Whether it's learning the power of saying hello or how courage comes with practice, their intimate reflections will inspire, move, and encourage you. Filled with the valuable insights distilled from a wide range of personal experiences.
Dan Gediman is the executive director of This I Believe, Inc., a non-profit organization that produces the popular podcast series of the same name. He has co-edited nine "This I Believe" books, including "This I Believe: Life Lessons" and the New York Times Bestseller "This I Believe: The Personal Philosophies of Remarkable Men and Women."
Dan is a long-time public radio producer whose work has been heard on "All Things Considered," "Morning Edition," "Marketplace," "Jazz Profiles" and "This American Life." During his long radio career, he has won many of public broadcasting's most prestigious awards, including the duPont-Columbia Award. Most recently, Dan produced the Audible documentary series "The Home Front: Life in America During World War II," which is narrated by Martin Sheen. Currently he is working on a new series, "The Reckoning: Confronting the Legacy of Slavery in America."
Registration/Tickets/RSVP:
https://newcollege.asu.edu/rsvp
Carolyn Starr
Carolyn.Starr@asu.edu
Sep 19 2019 - 6:00pm
University Center, La Sala Ballroom


text:
package org.hdiv.logger;

import java.util.Iterator;

import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.component.UIInput;
import javax.faces.component.UISelectBoolean;
import javax.faces.component.html.HtmlInputSecret;
import javax.faces.component.html.HtmlInputText;
import javax.faces.component.html.HtmlInputTextarea;
import javax.faces.context.FacesContext;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hdiv.logs.Logger;
import org.hdiv.util.HDIVErrorCodes;
import org.hdiv.util.UtilsJsf;

/**
 * Class for logging messages found in the components that show any
 * data modification by the user.
 *
 *
 * @author Gotzon Illarramendi
 *
 */
public class LogMessages {

	private static Log log = LogFactory.getLog(LogMessages.class);

	/**
	 * HDIV logger
	 */
	private Logger logger;

	/**
	 * Initilization method
	 *
	 * @param logger
	 *            active logger
	 */
	public void init(Logger logger) {
		this.logger = logger;
	}

	/**
	 * Searches for validation messages created by the framework itself that
	 * show value modification by the user and creates logs for them.
	 *
	 * @param facesContext
	 *            request context
	 */
	public void manageMessages(FacesContext facesContext) {
		Iterator clientIterator = facesContext.getClientIdsWithMessages();
		while (clientIterator.hasNext()) {
			String clientId = (String) clientIterator.next();

			HttpServletRequest request = (HttpServletRequest) facesContext.getExternalContext().getRequest();
			String requestValue = request.getParameter(clientId);

			// Remove row identifiers from clientId
			String clientIdWithoutRowId = UtilsJsf.removeRowId(clientId);

			UIComponent clientComponent = facesContext.getViewRoot().findComponent(clientIdWithoutRowId);
			Iterator clientMessages = facesContext.getMessages(clientId);
			manageClientMessages(requestValue, facesContext, clientComponent, clientMessages);
		}
	}

	/**
	 * Creates a log for the corresponding component
	 *
	 * @param requestValue
	 *            real value
	 * @param facesContext
	 *            request context
	 * @param clientComponent
	 *            component that has been modified
	 * @param clientMessages
	 *            messages created by the framework
	 */
	private void manageClientMessages(String requestValue, FacesContext facesContext, UIComponent clientComponent,
			Iterator clientMessages) {

		// If it is editable data, that is: HtmlInputText, HtmlInputTextarea
		// or HtmlInputSecret
		if (clientComponent instanceof UIInput) {

			boolean isTextEditable = (clientComponent instanceof HtmlInputText)
					|| (clientComponent instanceof HtmlInputTextarea) || (clientComponent instanceof HtmlInputSecret);
			boolean isUISelectBoolean = clientComponent instanceof UISelectBoolean;

			// If it is UISelectOne or UISelectMany:
			if ((!isTextEditable) && (!isUISelectBoolean)) {
				// Check all messages from component
				while (clientMessages.hasNext()) {
					FacesMessage message = (FacesMessage) clientMessages.next();
					if (log.isDebugEnabled()) {
						log.debug("Message detail:" + message.getDetail());
					}

					String value = null;
					if (clientComponent instanceof UIInput) {
						value = requestValue;
					}

					this.logger.log(HDIVErrorCodes.PARAMETER_VALUE_INCORRECT, LoggerUtil.getTarget(facesContext),
							clientComponent.getClientId(facesContext), value);

				}
			}
		}
	}

}


For somebody, it can be interesting but not for me. I don't like this topic and talk about this also. But maybe later I'll change my mind. by the way, now I still working on my essay for freshessay.net/. If you are interested in this you can check it.


Defeat that villain inside you that's killing your healthy vibe! Here's how to slay it & thrive in health for the long haul.
Tight on time? Tap here to watch the video instead of reading the blog & tap here for your free download of the 5 Step Blueprint!
If you're sick of starting a new nutrition or fitness plan every Monday only to lose steam by Thursday, or if you're frustrated about what it will take to keep you motivated to get & stay healthy in the long run, you're on the right blog.
No matter the time of year, upcoming event, or new number on the scale, you DO get motivated to up level your health! #WINNING! And while you may start out guns blazing, why is it that your motivation starts to fizzle fo sizzle weeks or even days in??
Is it because you're not seeing immediate results?
Is it because the goal you had in mind seems way out of your league?
Is it because life just keeps getting the way?
It can be many – if not not ALL – of these reasons. So what's it gonna take to stick to your biggest health goals? I've got the answer, and lucky for you, it's not rocket science.
Download your 5 Step Blueprint worksheet here so you can follow along with the video!
My 5 Step Blueprint to overcoming your roadblocks in reaching your biggest, boldest health goals. Get your accompanying worksheet here.
An invitation to a FREE Health Obstacle Breakthrough Call to get clear on your vision of health, pinpoint your personal action killers, and set specific action steps to get you started on your road to health hero status.
What if you could actually remember exactly WHAT it is you want for your health & what's DRIVING you to want it instead of just "wanting more energy" or "losing 10 pounds?" No, honey! We need to get WAY more specific than that if you TRULY want to succeed in becoming your optimal vision of health!
What if you knew EXACTLY what gets in the way of you accomplishing your health & wellness goals so that next time it blocks you, you just stare it straight in the face and push it to the side.
Download the 5 Step Blueprint here & watch the video explanation below or here!
When you're done, comment below or tag/message me on Instagram or Facebook @WholeHardy with what you found your biggest motivation killer to be!
Getting clear on what you want for your personal health & wellness takes intention & dedication.
Running on autopilot won't get you where you want to be.
Follow the 5 Steps in the worksheet. Then, if you'd like a little bit more guidance on locking these 5 Steps down so you can thrive confidently in health, hit me up at hello@wholehardy.com or tap here to schedule your free Health Obstacle Breakthrough Session.
Let's figure out your Action Killers together so we can slay them & get you to conquer that health & wellness quest you've been on for YEARS!
PS: Check out these value-packed posts on goal setting, goal crushing, and breaking those undesirable habits for good!
Why You Must FAIL to Succeed!
WholeHardy Health, LLC is an Integrative Health & Wellness Coaching Practice, helping you identify & defeat your motivation killers so you can thrive confidently in every aspect of life. Tap here to learn more about the WholeHardy Coaching Method. And tap here to schedule your FREE Health Obstacle Breakthrough Call.


text:
'If You Make A Mistake With Heroin, You're Dead': A Plan To Prevent Opioid Overdoses In Schools
WLRN 91.3 FM | By Jessica Bakeman
Published December 1, 2019 at 10:54 PM EST
A bill would allow schools to purchase naloxone, a drug that can be injected or sprayed nasally to revive people who are overdosing.
Florida schools could soon come equipped with the drug that reverses heroin overdoses.
A bill under consideration in the state Legislature would allow schools to obtain the drug naloxone, and let them train school staff members to administer it to students who they believe are suffering from overdoses.
The proposal comes as the Miami-Dade County school board has sued the manufacturers and distributors of addictive pain medications. The district claims it has had to divert resources from the classroom to offer nursing and mental health care to students and staff who've been affected by opioid addiction.
State Sen. Jason Pizzo proposed the bill after some local high school students approached him with the idea. A Democrat from North Miami Beach whose district includes parts of the city of Miami, Pizzo said his plan would address some of the overlooked victims of the opioid crisis: children.
"I'm a dad. I have 13-year-old identical twin boys. And I saw them this morning for 15 minutes. I'll see them tonight for 45 minutes — maybe, if I'm lucky, an hour and a half, if they don't think that I'm boring. But they're at school for the majority of their days, for the majority of a week, for the majority of the year," Pizzo said. "Anything that's going to potentially protect my sons' life, why wouldn't we advocate for it?"
Pizzo said he experimented with alcohol and marijuana when he was a kid, but the stakes weren't as high as they are for today's students.
"Maybe 30 years ago, when I was 13 years old, it was having a drink of something out of some parent's cabinet or smoking something that I had no idea what it was," Pizzo said. "Today is a lot different, because if you make that mistake with fentanyl, you're dead. If you make a mistake with heroin, you're dead."
Pizzo modeled the legislation after a bill that passed a few years ago allowing schools to obtain epinephrine auto-injectors — better known as EpiPens — and administer them to students suffering from life-threatening allergic reactions called anaphylaxis.
The bill language makes it optional for schools to participate. The Republican-led Legislature is less likely to approve a bill that places a requirement on schools without funding attached.
Pizzo doesn't expect the bill to be costly to implement, though. He said it's likely schools could get naloxone free or at a low cost from manufacturers, and the training to administer it is simple.
The legislation sailed through its first stop in the Legislature, earning unanimous support in the Senate Education Committee. It would have to clear two more committees before moving on to a vote on the Senate floor.
The legislative session starts Jan. 14.
Copyright 2020 WLRN 91.3 FM. To see more, visit WLRN 91.3 FM.
Health News Floridaschool boardheroindrug overdose
Jessica Bakeman
Jessica Bakeman reports on K-12 and higher education for WLRN, south Florida's NPR affiliate. While new to Miami and public radio, Jessica is a seasoned journalist who has covered education policymaking and politics in three state capitals: Jackson, Miss.; Albany, N.Y.; and, most recently, Tallahassee.
See stories by Jessica Bakeman
Senate Panel Signs Off On Overdose Drugs For Schools
Feds Plan Crackdown As Florida Fentanyl Deaths Rise
Purdue Pharma: Sackler Family's 'Personal Wealth' Offered In Opioid Deal


text:
Panchanada Sabanayagam (born 7 June 1922) is a retired Indian Administrative Service officer and a former Chief Secretary of Tamil Nadu.

Early life and military service
Sabanayagam was born in Madras (now Chennai) to S. Panchanada Mudaliar, a lawyer. After taking an honours degree from Madras Christian College in 1942 and leaving with the college's Ross Prize, he considered graduate studies, but instead applied for a commission in the British Indian Army and was selected. He completed basic training at the Officers' Training School, Mhow, and was then sent to Deolali Artillery School for a six-month course. On 25 June 1944, he received an emergency commission as a second lieutenant in the 10th Field Regiment of Indian Artillery, posted at Chhindwara. Impressing his commanding officer Colonel Gurney with his efficiency, Sabanayagam was promoted war-substantive lieutenant on 25 December 1944 and received further promotion to captain in October 1945 over eight more senior lieutenants, six of whom were British. He was subsequently selected for a regular commission and a posting to the United Kingdom to attend the Long Gunnery Staff Course. As his father wished him to join the civil service, he declined the offer and relinquished his commission.

Civil servant
The Indian government experienced shortages of qualified officers during the transitional period before and immediately after independence. As a consequence, Sabanayagam was appointed to the new Indian Administrative Service as a War Service Candidate on 20 March 1947, in the 1945 batch of officers. In the wake of Independence and partition on 15 August, his training was suspended while he and his fellow junior civil servants were dispatched to manage the resulting refugee crisis. He was then assigned to the Madras cadre and sent to the state in December 1947 to undergo training in district administration.

Sabanayagam served in various capacities under the Chief Ministers of Tamil Nadu until his retirement in 1980, his most notable position being that of Chief Secretary from 1971 to 1976. He turned 100 in June 2022, a milestone that was congratulated and praised by Chief Minister M. K. Stalin.

References

1922 births
Living people
Indian Administrative Service officers
British Indian Army officers
Military personnel from Chennai
Indian military personnel of World War II
Indian centenarians
Men centenarians

redpajama_set_name: RedPajamaWikipedia