sahpi_struct_utils_test.c

HIP 硬件设备管理标准接口

		default_writable_thresholds = 
			SAHPI_STM_LOW_MINOR | SAHPI_STM_LOW_MAJOR | SAHPI_STM_LOW_CRIT |
			SAHPI_STM_UP_MINOR | SAHPI_STM_UP_MAJOR |  SAHPI_STM_UP_CRIT |
			SAHPI_STM_UP_HYSTERESIS | SAHPI_STM_LOW_HYSTERESIS;

		/* oh_valid_thresholds: Bad parameters testcase */
		expected_err = SA_ERR_HPI_INVALID_PARAMS;
		err = oh_valid_thresholds(0, 0, default_writable_thresholds);
		if (err != expected_err) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received error=%s\n", oh_lookup_error(err));
			return -1;
		}
		
		/* oh_valid_thresholds: Bad threshold type testcase */
		test_thresholds_int64 = default_thresholds_int64;
		test_format_int64 = default_format_int64;
		test_writable_thresholds = default_writable_thresholds;
		
		expected_err = SA_ERR_HPI_INVALID_CMD;
		test_thresholds_int64.LowCritical.Type = SAHPI_SENSOR_READING_TYPE_FLOAT64;
		
		err = oh_valid_thresholds(&test_thresholds_int64, &test_format_int64, test_writable_thresholds);
		if (err != expected_err) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received error=%s\n", oh_lookup_error(err));
			return -1;
		}

		/* oh_valid_thresholds: Bad text buffer type threshold testcase */
		test_thresholds_int64 = default_thresholds_int64;
		test_format_int64 = default_format_int64;
		test_writable_thresholds = default_writable_thresholds;
		
		expected_err = SA_ERR_HPI_INVALID_CMD;
		test_thresholds_int64.LowCritical.Type = SAHPI_SENSOR_READING_TYPE_BUFFER;
		
		err = oh_valid_thresholds(&test_thresholds_int64, &test_format_int64, test_writable_thresholds);
		if (err != expected_err) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received error=%s\n", oh_lookup_error(err));
			return -1;
		}

		/* oh_valid_thresholds: Bad threshold hysteresis testcase */
		test_thresholds_int64 = default_thresholds_int64;
		test_format_int64 = default_format_int64;
		test_writable_thresholds = default_writable_thresholds;
		
		expected_err = SA_ERR_HPI_INVALID_DATA;
		test_thresholds_int64.PosThdHysteresis.Value.SensorInt64 = -1;
		
		err = oh_valid_thresholds(&test_thresholds_int64, &test_format_int64, test_writable_thresholds);
		if (err != expected_err) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received error=%s\n", oh_lookup_error(err));
			return -1;
		}

		/* oh_valid_thresholds: Bad range threshold testcase */
		test_thresholds_int64 = default_thresholds_int64;
		test_format_int64 = default_format_int64;
		test_writable_thresholds = default_writable_thresholds;
		
		expected_err = SA_ERR_HPI_INVALID_CMD;
		test_format_int64.Range.Max.Value.SensorInt64 = 0;
		
		err = oh_valid_thresholds(&test_thresholds_int64, &test_format_int64, test_writable_thresholds);
		if (err != expected_err) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received error=%s\n", oh_lookup_error(err));
			return -1;
		}
		
		/* oh_valid_thresholds: Bad order threshold testcase */
		test_thresholds_int64 = default_thresholds_int64;
		test_format_int64 = default_format_int64;
		test_writable_thresholds = default_writable_thresholds;

		test_thresholds_int64.LowCritical.Value.SensorInt64 = 20;
		expected_err = SA_ERR_HPI_INVALID_DATA;
		
		err = oh_valid_thresholds(&test_thresholds_int64, &test_format_int64, test_writable_thresholds);
		if (err != expected_err) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received error=%s\n", oh_lookup_error(err));
			return -1;
		}

		/* oh_valid_thresholds: Bad writable threshold testcase */
		test_thresholds_int64 = default_thresholds_int64;
		test_format_int64 = default_format_int64;
		test_writable_thresholds = default_writable_thresholds;

		test_writable_thresholds = SAHPI_STM_LOW_MINOR | SAHPI_STM_LOW_MAJOR | SAHPI_STM_LOW_CRIT;
		expected_err = SA_ERR_HPI_INVALID_CMD;
		
		err = oh_valid_thresholds(&test_thresholds_int64, &test_format_int64, test_writable_thresholds);
		if (err != expected_err) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received error=%s\n", oh_lookup_error(err));
			return -1;
		}

		/* oh_valid_thresholds: Normal threshold testcase - int64 */
		test_thresholds_int64 = default_thresholds_int64;
		test_format_int64 = default_format_int64;
		test_writable_thresholds = default_writable_thresholds;

		expected_err = SA_OK;
		
		err = oh_valid_thresholds(&test_thresholds_int64, &test_format_int64, test_writable_thresholds);
		if (err != expected_err) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received error=%s\n", oh_lookup_error(err));
			return -1;
		}

		/* oh_valid_thresholds: Normal subset testcase */
		test_thresholds_int64 = default_thresholds_int64;
		test_format_int64 = default_format_int64;
		test_writable_thresholds = default_writable_thresholds;

		test_thresholds_int64.UpCritical.IsSupported = SAHPI_FALSE;
		test_thresholds_int64.UpCritical.Type = BAD_TYPE; /* This should be ignored */
		test_thresholds_int64.LowCritical.IsSupported = SAHPI_FALSE;
		test_thresholds_int64.LowCritical.Type = BAD_TYPE; /* This should be ignored */

		expected_err = SA_OK;
		
		err = oh_valid_thresholds(&test_thresholds_int64, &test_format_int64, test_writable_thresholds);
		if (err != expected_err) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received error=%s\n", oh_lookup_error(err));
			return -1;
		}

 		default_thresholds_float64.UpCritical.IsSupported = SAHPI_TRUE;
		default_thresholds_float64.UpCritical.Type = SAHPI_SENSOR_READING_TYPE_FLOAT64;
		default_thresholds_float64.UpCritical.Value.SensorFloat64 = 50.3;
		default_thresholds_float64.UpMajor.IsSupported = SAHPI_TRUE;
		default_thresholds_float64.UpMajor.Type = SAHPI_SENSOR_READING_TYPE_FLOAT64;
		default_thresholds_float64.UpMajor.Value.SensorFloat64 = 40.2;
		default_thresholds_float64.UpMinor.IsSupported = SAHPI_TRUE;
		default_thresholds_float64.UpMinor.Type = SAHPI_SENSOR_READING_TYPE_FLOAT64;
		default_thresholds_float64.UpMinor.Value.SensorFloat64 = 30.1;
		default_thresholds_float64.LowMinor.IsSupported = SAHPI_TRUE;
		default_thresholds_float64.LowMinor.Type = SAHPI_SENSOR_READING_TYPE_FLOAT64;
		default_thresholds_float64.LowMinor.Value.SensorFloat64 = 20.3;
		default_thresholds_float64.LowMajor.IsSupported = SAHPI_TRUE;
		default_thresholds_float64.LowMajor.Type = SAHPI_SENSOR_READING_TYPE_FLOAT64;
		default_thresholds_float64.LowMajor.Value.SensorFloat64 = 10.2;
		default_thresholds_float64.LowCritical.IsSupported = SAHPI_TRUE;
		default_thresholds_float64.LowCritical.Type = SAHPI_SENSOR_READING_TYPE_FLOAT64;
		default_thresholds_float64.LowCritical.Value.SensorFloat64 = 0.5;
		default_thresholds_float64.PosThdHysteresis.IsSupported = SAHPI_TRUE;
		default_thresholds_float64.PosThdHysteresis.Type = SAHPI_SENSOR_READING_TYPE_FLOAT64;
		default_thresholds_float64.PosThdHysteresis.Value.SensorFloat64 = 2;
		default_thresholds_float64.NegThdHysteresis.IsSupported = SAHPI_TRUE;
		default_thresholds_float64.NegThdHysteresis.Type = SAHPI_SENSOR_READING_TYPE_FLOAT64;
		default_thresholds_float64.NegThdHysteresis.Value.SensorFloat64 = 2;

		default_format_float64.IsSupported = SAHPI_TRUE;
		default_format_float64.ReadingType = SAHPI_SENSOR_READING_TYPE_FLOAT64;
		default_format_float64.Range.Flags = SAHPI_SRF_MAX | SAHPI_SRF_MIN;
		default_format_float64.Range.Max.Value.SensorFloat64 = 60;
		default_format_float64.Range.Min.Value.SensorFloat64 = 0;

                /* oh_valid_thresholds: Normal threshold testcase - float64 */
		test_thresholds_float64 = default_thresholds_float64;
		test_format_float64 = default_format_float64;
		test_writable_thresholds = default_writable_thresholds;

		expected_err = SA_OK;
		
		err = oh_valid_thresholds(&test_thresholds_float64, &test_format_float64, test_writable_thresholds);
		if (err != expected_err) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received error=%s\n", oh_lookup_error(err));
			return -1;
		}

 		default_thresholds_uint64.UpCritical.IsSupported = SAHPI_TRUE;
		default_thresholds_uint64.UpCritical.Type = SAHPI_SENSOR_READING_TYPE_UINT64;
		default_thresholds_uint64.UpCritical.Value.SensorUint64 = 50.3;
		default_thresholds_uint64.UpMajor.IsSupported = SAHPI_TRUE;
		default_thresholds_uint64.UpMajor.Type = SAHPI_SENSOR_READING_TYPE_UINT64;
		default_thresholds_uint64.UpMajor.Value.SensorUint64 = 40.2;
		default_thresholds_uint64.UpMinor.IsSupported = SAHPI_TRUE;
		default_thresholds_uint64.UpMinor.Type = SAHPI_SENSOR_READING_TYPE_UINT64;
		default_thresholds_uint64.UpMinor.Value.SensorUint64 = 30.1;
		default_thresholds_uint64.LowMinor.IsSupported = SAHPI_TRUE;
		default_thresholds_uint64.LowMinor.Type = SAHPI_SENSOR_READING_TYPE_UINT64;
		default_thresholds_uint64.LowMinor.Value.SensorUint64 = 20.3;
		default_thresholds_uint64.LowMajor.IsSupported = SAHPI_TRUE;
		default_thresholds_uint64.LowMajor.Type = SAHPI_SENSOR_READING_TYPE_UINT64;
		default_thresholds_uint64.LowMajor.Value.SensorUint64 = 10.2;
		default_thresholds_uint64.LowCritical.IsSupported = SAHPI_TRUE;
		default_thresholds_uint64.LowCritical.Type = SAHPI_SENSOR_READING_TYPE_UINT64;
		default_thresholds_uint64.LowCritical.Value.SensorUint64 = 0.5;
		default_thresholds_uint64.PosThdHysteresis.IsSupported = SAHPI_TRUE;
		default_thresholds_uint64.PosThdHysteresis.Type = SAHPI_SENSOR_READING_TYPE_UINT64;
		default_thresholds_uint64.PosThdHysteresis.Value.SensorUint64 = 2;
		default_thresholds_uint64.NegThdHysteresis.IsSupported = SAHPI_TRUE;
		default_thresholds_uint64.NegThdHysteresis.Type = SAHPI_SENSOR_READING_TYPE_UINT64;
		default_thresholds_uint64.NegThdHysteresis.Value.SensorUint64 = 2;

		default_format_uint64.IsSupported = SAHPI_TRUE;
		default_format_uint64.ReadingType = SAHPI_SENSOR_READING_TYPE_UINT64;
		default_format_uint64.Range.Flags = SAHPI_SRF_MAX | SAHPI_SRF_MIN;
		default_format_uint64.Range.Max.Value.SensorUint64 = 60;
		default_format_uint64.Range.Min.Value.SensorUint64 = 0;

		/* oh_valid_thresholds: Normal threshold testcase - uint64*/
		test_thresholds_uint64 = default_thresholds_uint64;
		test_format_uint64 = default_format_uint64;
		test_writable_thresholds = default_writable_thresholds;

		expected_err = SA_OK;
		
		err = oh_valid_thresholds(&test_thresholds_uint64, &test_format_uint64, test_writable_thresholds);
		if (err != expected_err) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received error=%s\n", oh_lookup_error(err));
			return -1;
		}
	}

	/************************************
	 * oh_compare_sensorreading testcases
         ************************************/
	{
		SaHpiSensorReadingT reading1, reading2;
		int rtn, expected_rtn;

		reading1.IsSupported = reading2.IsSupported = SAHPI_TRUE;
		reading1.Type = reading2.Type = SAHPI_SENSOR_READING_TYPE_FLOAT64;
		
		/* oh_compare_sensorreading - reading1 < reading2 float64 */
		reading1.Value.SensorFloat64 = 5;
		reading2.Value.SensorFloat64 = 10;
		expected_rtn = -1;
		rtn = oh_compare_sensorreading(reading1.Type, &reading1, &reading2);
		if (rtn != expected_rtn) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received return code=%d\n", rtn);
			return -1;
		}

		/* oh_compare_sensorreading - reading1 = reading2 float64 */
		reading1.Value.SensorFloat64 = 5;
		reading2.Value.SensorFloat64 = 5;
		expected_rtn = 0;
		rtn = oh_compare_sensorreading(reading1.Type, &reading1, &reading2);
		if (rtn != expected_rtn) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received return code=%d\n", rtn);
			return -1;
		}

		/* oh_compare_sensorreading - reading1 = reading2 float64 */
		reading1.Value.SensorFloat64 = 10;
		reading2.Value.SensorFloat64 = 5;
		expected_rtn = 1;
		rtn = oh_compare_sensorreading(reading1.Type, &reading1, &reading2);
		if (rtn != expected_rtn) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received return code=%d\n", rtn);
			return -1;
		}

		reading1.Type = reading2.Type = SAHPI_SENSOR_READING_TYPE_INT64;
		/* oh_compare_sensorreading - reading1 < reading2 int64 */
		reading1.Value.SensorInt64 = 5;
		reading2.Value.SensorInt64 = 10;
		expected_rtn = -1;
		rtn = oh_compare_sensorreading(reading1.Type, &reading1, &reading2);
		if (rtn != expected_rtn) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received return code=%d\n", rtn);
			return -1;
		}

		/* oh_compare_sensorreading - reading1 = reading2 int64 */
		reading1.Value.SensorInt64 = 5;
		reading2.Value.SensorInt64 = 5;
		expected_rtn = 0;
		rtn = oh_compare_sensorreading(reading1.Type, &reading1, &reading2);
		if (rtn != expected_rtn) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received return code=%d\n", rtn);
			return -1;
		}

		/* oh_compare_sensorreading - reading1 = reading2 int64 */
		reading1.Value.SensorInt64 = 10;
		reading2.Value.SensorInt64 = 5;
		expected_rtn = 1;
		rtn = oh_compare_sensorreading(reading1.Type, &reading1, &reading2);
		if (rtn != expected_rtn) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received return code=%d\n", rtn);
			return -1;
		}

		reading1.Type = reading2.Type = SAHPI_SENSOR_READING_TYPE_UINT64;
		/* oh_compare_sensorreading - reading1 < reading2 uint64 */
		reading1.Value.SensorUint64 = 5;
		reading2.Value.SensorUint64 = 10;
		expected_rtn = -1;
		rtn = oh_compare_sensorreading(reading1.Type, &reading1, &reading2);
		if (rtn != expected_rtn) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received return code=%d\n", rtn);
			return -1;
		}

		/* oh_compare_sensorreading - reading1 = reading2 uint64 */
		reading1.Value.SensorUint64 = 5;
		reading2.Value.SensorUint64 = 5;
		expected_rtn = 0;
		rtn = oh_compare_sensorreading(reading1.Type, &reading1, &reading2);
		if (rtn != expected_rtn) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received return code=%d\n", rtn);
			return -1;
		}

		/* oh_compare_sensorreading - reading1 = reading2 uint64 */
		reading1.Value.SensorUint64 = 10;
		reading2.Value.SensorUint64 = 5;
		expected_rtn = 1;
		rtn = oh_compare_sensorreading(reading1.Type, &reading1, &reading2);
		if (rtn != expected_rtn) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received return code=%d\n", rtn);
			return -1;
		}

		reading1.Type = reading2.Type = SAHPI_SENSOR_READING_TYPE_BUFFER;
		/* oh_compare_sensorreading - reading1 < reading2 uint64 */
		strncpy(reading1.Value.SensorBuffer, "AAA", SAHPI_SENSOR_BUFFER_LENGTH);
		strncpy(reading2.Value.SensorBuffer, "BBB", SAHPI_SENSOR_BUFFER_LENGTH);
		expected_rtn = -1;
		rtn = oh_compare_sensorreading(reading1.Type, &reading1, &reading2);
		if (rtn != expected_rtn) {	
			printf("  Error! Testcase failed. Line=%d\n", __LINE__);
			printf("  Received return code=%d\n", rtn);
			return -1;
		}
	}

	return(0);
}