lib.rs

			);
			assert_eq!(
				outbound_lane::<TestRuntime, ()>(TEST_LANE_ID_2).data().oldest_unpruned_nonce,
				1
			);

			// in block#3.on_idle lane messages of lane 2 are pruned
			System::<TestRuntime>::set_block_number(3);

			assert_eq!(
				Pallet::<TestRuntime, ()>::on_idle(0, dbw.reads_writes(100, 100)),
				dbw.reads_writes(1, 2),
			);
			assert_eq!(
				outbound_lane::<TestRuntime, ()>(TEST_LANE_ID).data().oldest_unpruned_nonce,
				2
			);
			assert_eq!(
				outbound_lane::<TestRuntime, ()>(TEST_LANE_ID_2).data().oldest_unpruned_nonce,
				2
			);
		});
	}

	#[test]
	fn outbound_message_from_unconfigured_lane_is_rejected() {
		run_test(|| {
			assert_noop!(
				send_message::<TestRuntime, ()>(
					RuntimeOrigin::signed(1),
					TEST_LANE_ID_3,
					REGULAR_PAYLOAD,
				),
				Error::<TestRuntime, ()>::InactiveOutboundLane,
			);
		});
	}

	#[test]
	fn test_bridge_messages_call_is_correctly_defined() {
		let account_id = 1;
		let message_proof: TestMessagesProof = Ok(vec![message(1, REGULAR_PAYLOAD)]).into();
		let message_delivery_proof = TestMessagesDeliveryProof(Ok((
			TEST_LANE_ID,
			InboundLaneData {
				last_confirmed_nonce: 1,
				relayers: vec![UnrewardedRelayer {
					relayer: 0,
					messages: DeliveredMessages::new(1),
				}]
				.into_iter()
				.collect(),
			},
		)));
		let unrewarded_relayer_state = UnrewardedRelayersState {
			unrewarded_relayer_entries: 1,
			total_messages: 1,
			last_delivered_nonce: 1,
			..Default::default()
		};

		let direct_receive_messages_proof_call = Call::<TestRuntime>::receive_messages_proof {
			relayer_id_at_bridged_chain: account_id,
			proof: message_proof.clone(),
			messages_count: 1,
			dispatch_weight: REGULAR_PAYLOAD.declared_weight,
		};
		let indirect_receive_messages_proof_call = BridgeMessagesCall::<
			AccountId,
			TestMessagesProof,
			TestMessagesDeliveryProof,
		>::receive_messages_proof {
			relayer_id_at_bridged_chain: account_id,
			proof: message_proof,
			messages_count: 1,
			dispatch_weight: REGULAR_PAYLOAD.declared_weight,
		};
		assert_eq!(
			direct_receive_messages_proof_call.encode(),
			indirect_receive_messages_proof_call.encode()
		);

		let direct_receive_messages_delivery_proof_call =
			Call::<TestRuntime>::receive_messages_delivery_proof {
				proof: message_delivery_proof.clone(),
				relayers_state: unrewarded_relayer_state.clone(),
			};
		let indirect_receive_messages_delivery_proof_call = BridgeMessagesCall::<
			AccountId,
			TestMessagesProof,
			TestMessagesDeliveryProof,
		>::receive_messages_delivery_proof {
			proof: message_delivery_proof,
			relayers_state: unrewarded_relayer_state,
		};
		assert_eq!(
			direct_receive_messages_delivery_proof_call.encode(),
			indirect_receive_messages_delivery_proof_call.encode()
		);
	}

	generate_owned_bridge_module_tests!(
		MessagesOperatingMode::Basic(BasicOperatingMode::Normal),
		MessagesOperatingMode::Basic(BasicOperatingMode::Halted)
	);

	#[test]
	fn inbound_storage_extra_proof_size_bytes_works() {
		fn relayer_entry() -> UnrewardedRelayer<TestRelayer> {
			UnrewardedRelayer { relayer: 42u64, messages: DeliveredMessages { begin: 0, end: 100 } }
		}

		fn storage(relayer_entries: usize) -> RuntimeInboundLaneStorage<TestRuntime, ()> {
			RuntimeInboundLaneStorage {
				lane_id: Default::default(),
				cached_data: RefCell::new(Some(InboundLaneData {
					relayers: vec![relayer_entry(); relayer_entries].into_iter().collect(),
					last_confirmed_nonce: 0,
				})),
				_phantom: Default::default(),
			}
		}

		let max_entries = crate::mock::MaxUnrewardedRelayerEntriesAtInboundLane::get() as usize;

		// when we have exactly `MaxUnrewardedRelayerEntriesAtInboundLane` unrewarded relayers
		assert_eq!(storage(max_entries).extra_proof_size_bytes(), 0);

		// when we have less than `MaxUnrewardedRelayerEntriesAtInboundLane` unrewarded relayers
		assert_eq!(
			storage(max_entries - 1).extra_proof_size_bytes(),
			relayer_entry().encode().len() as u64
		);
		assert_eq!(
			storage(max_entries - 2).extra_proof_size_bytes(),
			2 * relayer_entry().encode().len() as u64
		);

		// when we have more than `MaxUnrewardedRelayerEntriesAtInboundLane` unrewarded relayers
		// (shall not happen in practice)
		assert_eq!(storage(max_entries + 1).extra_proof_size_bytes(), 0);
	}

	#[test]
	fn maybe_outbound_lanes_count_returns_correct_value() {
		assert_eq!(
			MaybeOutboundLanesCount::<TestRuntime, ()>::get(),
			Some(mock::ActiveOutboundLanes::get().len() as u32)
		);
	}
}